X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fextra%2Fm_pgsql.cpp;h=df0ca7f4266bb88430a3aa9b9d894822bef4b9d9;hb=7e843c22e16c81054bad18073d24fe1a07026431;hp=602e1ce77e1a436016d5237a4497c7160a0f3b5c;hpb=0392e44ac5ba056bce4e36d54a88ee13ee61d3a8;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/extra/m_pgsql.cpp b/src/modules/extra/m_pgsql.cpp index 602e1ce77..df0ca7f42 100644 --- a/src/modules/extra/m_pgsql.cpp +++ b/src/modules/extra/m_pgsql.cpp @@ -2,8 +2,8 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd: (C) 2002-2007 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * InspIRCd: (C) 2002-2009 InspIRCd Development Team + * See: http://wiki.inspircd.org/Credits * * This program is free but copyrighted software; see * the file COPYING for details. @@ -11,31 +11,21 @@ * --------------------------------------------------- */ +#include "inspircd.h" #include #include -#include -#include -#include #include - -#include "users.h" -#include "channels.h" -#include "modules.h" - -#include "inspircd.h" -#include "configreader.h" - #include "m_sqlv2.h" /* $ModDesc: PostgreSQL Service Provider module for all other m_sql* modules, uses v2 of the SQL API */ -/* $CompileFlags: -I`pg_config --includedir` `perl extra/pgsql_config.pl` */ -/* $LinkerFlags: -L`pg_config --libdir` -lpq */ +/* $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 */ /* $ModDep: m_sqlv2.h */ /* SQLConn rewritten by peavey to * use EventHandler instead of - * InspSocket. This is much neater + * BufferedSocket. This is much neater * and gives total control of destroy * and delete of resources. */ @@ -54,14 +44,25 @@ typedef std::map ConnMap; */ enum SQLstatus { CREAD, CWRITE, WREAD, WWRITE, RREAD, RWRITE }; +unsigned long count(const char * const str, char a) +{ + unsigned long n = 0; + for (const char *p = str; *p; ++p) + { + if (*p == '?') + ++n; + } + return n; +} + /** SQLhost::GetDSN() - Overload to return correct DSN for PostgreSQL */ std::string SQLhost::GetDSN() { - std::ostringstream conninfo("connect_timeout = '2'"); + std::ostringstream conninfo("connect_timeout = '5'"); - if (ip.length()) - conninfo << " hostaddr = '" << ip << "'"; + if (host.length()) + conninfo << " host = '" << host << "'"; if (port) conninfo << " port = '" << port << "'"; @@ -87,175 +88,17 @@ std::string SQLhost::GetDSN() return conninfo.str(); } -class ReconnectTimer : public InspTimer -{ - private: - SQLConn* conn; - Module* mod; - public: - ReconnectTimer(InspIRCd* SI, SQLConn* c, Module* m) - : InspTimer(5, SI->Time(), false), conn(c), mod(m) - { - } - virtual void Tick(time_t TIME); -}; - - -/** Used to resolve sql server hostnames - */ -class SQLresolver : public Resolver +class ReconnectTimer : public Timer { private: - SQLhost host; - Module* mod; + Module* const mod; public: - SQLresolver(Module* m, InspIRCd* Instance, const SQLhost& hi, bool &cached) - : Resolver(Instance, hi.host, DNS_QUERY_FORWARD, cached, (Module*)m), host(hi), mod(m) - { - } - - virtual void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached); - - virtual void OnError(ResolverError e, const std::string &errormessage) + ReconnectTimer(Module* m) : Timer(5, ServerInstance->Time(), false), mod(m) { - ServerInstance->Log(DEBUG, "DNS lookup failed (%s), dying horribly", errormessage.c_str()); } + virtual void Tick(time_t TIME); }; -/** 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. - * - * We store lists of SQLrequest's here, by value as we want to avoid storing - * any data allocated inside the client module (in case that module is unloaded - * while the query is in progress). - * - * Because we want to work on the current SQLrequest in-situ, we need a way - * of accessing the request we are currently processing, QueryQueue::front(), - * but that call needs to always return the same request until that request - * 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. - */ - -class QueryQueue : public classbase -{ -private: - typedef std::deque ReqDeque; - - ReqDeque priority; /* The priority queue */ - ReqDeque normal; /* The 'normal' queue */ - enum { PRI, NOR, NON } which; /* Which queue the currently active element is at the front of */ - -public: - QueryQueue() - : which(NON) - { - } - - void push(const SQLrequest &q) - { - //ServerInstance->Log(DEBUG, "QueryQueue::push(): Adding %s query to queue: %s", ((q.pri) ? "priority" : "non-priority"), q.query.q.c_str()); - - if(q.pri) - priority.push_back(q); - else - normal.push_back(q); - } - - void pop() - { - if((which == PRI) && priority.size()) - { - priority.pop_front(); - } - else if((which == NOR) && normal.size()) - { - normal.pop_front(); - } - - /* Reset this */ - which = NON; - - /* Silently do nothing if there was no element to pop() */ - } - - SQLrequest& front() - { - switch(which) - { - 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(); - } - } - - std::pair size() - { - return std::make_pair(priority.size(), normal.size()); - } - - int totalsize() - { - return priority.size() + normal.size(); - } - - void PurgeModule(Module* mod) - { - DoPurgeModule(mod, priority); - DoPurgeModule(mod, normal); - } - -private: - void DoPurgeModule(Module* mod, ReqDeque& q) - { - for(ReqDeque::iterator iter = q.begin(); iter != q.end(); iter++) - { - if(iter->GetSource() == mod) - { - if(iter->id == front().id) - { - /* It's the currently active query.. :x */ - iter->SetSource(NULL); - } - else - { - /* It hasn't been executed yet..just remove it */ - iter = q.erase(iter); - } - } - } - } -}; /** 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 @@ -274,23 +117,21 @@ class PgSQLresult : public SQLresult SQLfieldList* fieldlist; SQLfieldMap* fieldmap; public: - PgSQLresult(Module* self, Module* to, unsigned long id, PGresult* result) - : SQLresult(self, to, id), res(result), currentrow(0), fieldlist(NULL), fieldmap(NULL) + PgSQLresult(Module* self, Module* to, unsigned long rid, PGresult* result) + : SQLresult(self, to, rid), res(result), currentrow(0), fieldlist(NULL), fieldmap(NULL) { rows = PQntuples(res); cols = PQnfields(res); - - //ServerInstance->Log(DEBUG, "Created new PgSQL result; %d rows, %d columns, %s affected", rows, cols, PQcmdTuples(res)); } ~PgSQLresult() { /* If we allocated these, free them... */ if(fieldlist) - DELETE(fieldlist); + delete fieldlist; if(fieldmap) - DELETE(fieldmap); + delete fieldmap; PQclear(res); } @@ -343,7 +184,6 @@ public: } else { - //ServerInstance->Log(DEBUG, "PQgetvalue returned a null pointer..nobody wants to tell us what this means"); throw SQLbadColName(); } } @@ -364,9 +204,9 @@ public: if(currentrow < PQntuples(res)) { - int cols = PQnfields(res); + int ncols = PQnfields(res); - for(int i = 0; i < cols; i++) + for(int i = 0; i < ncols; i++) { fieldlist->push_back(GetValue(currentrow, i)); } @@ -393,9 +233,9 @@ public: if(currentrow < PQntuples(res)) { - int cols = PQnfields(res); + int ncols = PQnfields(res); - for(int i = 0; i < cols; i++) + for(int i = 0; i < ncols; i++) { fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i))); } @@ -412,9 +252,9 @@ public: if(currentrow < PQntuples(res)) { - int cols = PQnfields(res); + int ncols = PQnfields(res); - for(int i = 0; i < cols; i++) + for(int i = 0; i < ncols; i++) { fl->push_back(GetValue(currentrow, i)); } @@ -431,9 +271,9 @@ public: if(currentrow < PQntuples(res)) { - int cols = PQnfields(res); + int ncols = PQnfields(res); - for(int i = 0; i < cols; i++) + for(int i = 0; i < ncols; i++) { fm->insert(std::make_pair(ColName(i), GetValue(currentrow, i))); } @@ -446,12 +286,12 @@ public: virtual void Free(SQLfieldMap* fm) { - DELETE(fm); + delete fm; } virtual void Free(SQLfieldList* fl) { - DELETE(fl); + delete fl; } }; @@ -459,8 +299,7 @@ public: */ class SQLConn : public EventHandler { - private: - InspIRCd* Instance; + private: SQLhost confhost; /* The entry */ Module* us; /* Pointer to the SQL provider itself */ PGconn* sql; /* PgSQL database connection handle */ @@ -469,15 +308,14 @@ class SQLConn : public EventHandler QueryQueue queue; /* Queue of queries waiting to be executed on this connection */ time_t idle; /* Time we last heard from the database */ - public: - SQLConn(InspIRCd* SI, Module* self, const SQLhost& hi) - : EventHandler(), Instance(SI), confhost(hi), us(self), sql(NULL), status(CWRITE), qinprog(false) + public: + SQLConn(Module* self, const SQLhost& hi) + : EventHandler(), confhost(hi), us(self), sql(NULL), status(CWRITE), qinprog(false) { - idle = this->Instance->Time(); + idle = ServerInstance->Time(); if(!DoConnect()) { - Instance->Log(DEFAULT, "WARNING: Could not connect to database with id: " + ConvToStr(hi.id)); - Close(); + ServerInstance->Logs->Log("m_pgsql",DEFAULT, "WARNING: Could not connect to database with id: " + ConvToStr(hi.id)); DelayReconnect(); } } @@ -500,7 +338,6 @@ class SQLConn : public EventHandler break; case EVENT_ERROR: - Close(); DelayReconnect(); break; @@ -512,57 +349,48 @@ class SQLConn : public EventHandler bool DoConnect() { if(!(sql = PQconnectStart(confhost.GetDSN().c_str()))) - { - Instance->Log(DEBUG, "Couldn't allocate PGconn structure, aborting: %s", PQerrorMessage(sql)); return false; - } + if(PQstatus(sql) == CONNECTION_BAD) - { - Instance->Log(DEBUG, "PQconnectStart failed: %s", PQerrorMessage(sql)); return false; - } - ShowStatus(); + if(PQsetnonblocking(sql, 1) == -1) - { - Instance->Log(DEBUG, "Couldn't set connection nonblocking: %s", PQerrorMessage(sql)); return false; - } - this->fd = PQsocket(sql); - Instance->Log(DEBUG, "New SQL socket: %d", this->fd); + /* OK, we've initalised the connection, now to get it hooked into the socket engine + * and then start polling it. + */ + this->fd = PQsocket(sql); if(this->fd <= -1) - { - Instance->Log(DEBUG, "PQsocket says we have an invalid FD: %d", this->fd); return false; - } - if (!this->Instance->SE->AddFd(this)) + if (!ServerInstance->SE->AddFd(this, FD_WANT_NO_WRITE | FD_WANT_NO_READ)) { - Instance->Log(DEBUG, "A PQsocket cant be added to the socket engine!"); + ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: Couldn't add pgsql socket to socket engine"); return false; } /* Socket all hooked into the engine, now to tell PgSQL to start connecting */ - return DoPoll(); } bool DoPoll() { - ShowStatus(); switch(PQconnectPoll(sql)) { case PGRES_POLLING_WRITING: - Instance->SE->WantWrite(this); + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_WRITE | FD_WANT_NO_READ); status = CWRITE; return true; 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; return DoConnectedPoll(); default: @@ -575,36 +403,28 @@ class SQLConn : public EventHandler if(!qinprog && queue.totalsize()) { /* There's no query currently in progress, and there's queries in the queue. */ - SQLrequest& query = queue.front(); - DoQuery(query); + SQLrequest* query = queue.front(); + DoQuery(*query); } if(PQconsumeInput(sql)) { - Instance->Log(DEBUG, "PQconsumeInput succeeded"); - /* We just read stuff from the server, that counts as it being alive * so update the idle-since time :p */ - idle = this->Instance->Time(); - - ShowStatus(); + idle = ServerInstance->Time(); - if(PQisBusy(sql)) + if (PQisBusy(sql)) { - Instance->Log(DEBUG, "Still busy processing command though"); + /* Nothing happens here */ } - else if(qinprog) + else if (qinprog) { - //ServerInstance->Log(DEBUG, "Looks like we have a result to process!"); - /* Grab the request we're processing */ - SQLrequest& query = queue.front(); - - Instance->Log(DEBUG, "ID is %lu", query.id); + SQLrequest* query = queue.front(); /* Get a pointer to the module we're about to return the result to */ - Module* to = query.GetSource(); + Module* to = query->source; /* Fetch the result.. */ PGresult* result = PQgetResult(sql); @@ -624,21 +444,20 @@ class SQLConn : public EventHandler if(to) { /* ..and the result */ - PgSQLresult reply(us, to, query.id, result); + PgSQLresult reply(us, to, query->id, result); /* Fix by brain, make sure the original query gets sent back in the reply */ - reply.query = query.query.q; - - Instance->Log(DEBUG, "Got result, status code: %s; error message: %s", PQresStatus(PQresultStatus(result)), PQresultErrorMessage(result)); + reply.query = query->query.q; switch(PQresultStatus(result)) { case PGRES_EMPTY_QUERY: case PGRES_BAD_RESPONSE: case PGRES_FATAL_ERROR: - reply.error.Id(QREPLY_FAIL); + reply.error.Id(SQL_QREPLY_FAIL); reply.error.Str(PQresultErrorMessage(result)); - default:; + default: + ; /* No action, other values are not errors */ } @@ -652,18 +471,12 @@ class SQLConn : public EventHandler * the pointer to NULL. We cannot just cancel the query as the result will still come * through at some point...and it could get messy if we play with invalid pointers... */ - 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); PQclear(result); } qinprog = false; queue.pop(); DoConnectedPoll(); } - else - { - ShowStatus(); - Instance->Log(DEBUG, "Eh!? We just got a read event, and connection isn't busy..but no result :("); - } return true; } else @@ -673,10 +486,8 @@ class SQLConn : public EventHandler * deserves to reconnect [/excuse] * Returning true so the core doesn't try and close the connection. */ - Instance->Log(DEBUG, "PQconsumeInput failed: %s", PQerrorMessage(sql)); - Close(); DelayReconnect(); - return false; + return true; } } @@ -685,93 +496,42 @@ class SQLConn : public EventHandler switch(PQresetPoll(sql)) { case PGRES_POLLING_WRITING: - //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_WRITING"); - Instance->SE->WantWrite(this); + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_WRITE | FD_WANT_NO_READ); status = CWRITE; - return DoResetPoll(); + return DoPoll(); case PGRES_POLLING_READING: - //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_READING"); + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); status = CREAD; return true; case PGRES_POLLING_FAILED: - //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_FAILED: %s", PQerrorMessage(sql)); return false; case PGRES_POLLING_OK: - //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_OK"); + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); status = WWRITE; return DoConnectedPoll(); default: - //ServerInstance->Log(DEBUG, "PGresetPoll: wtf?"); return true; } } - void ShowStatus() - { - switch(PQstatus(sql)) - { - case CONNECTION_OK: - Instance->Log(DEBUG, "PQstatus: CONNECTION_OK: Ok."); - break; - - case CONNECTION_BAD: - Instance->Log(DEBUG, "PQstatus: CONNECTION_BAD: Bad."); - break; - - case CONNECTION_STARTED: - Instance->Log(DEBUG, "PQstatus: CONNECTION_STARTED: Waiting for connection to be made."); - break; - - case CONNECTION_MADE: - Instance->Log(DEBUG, "PQstatus: CONNECTION_MADE: Connection OK; waiting to send."); - break; - - case CONNECTION_AWAITING_RESPONSE: - Instance->Log(DEBUG, "PQstatus: CONNECTION_AWAITING_RESPONSE: Waiting for a response from the server."); - break; - - case CONNECTION_AUTH_OK: - Instance->Log(DEBUG, "PQstatus: CONNECTION_AUTH_OK: Received authentication; waiting for backend start-up to finish."); - break; - - case CONNECTION_SSL_STARTUP: - Instance->Log(DEBUG, "PQstatus: CONNECTION_SSL_STARTUP: Negotiating SSL encryption."); - break; - - case CONNECTION_SETENV: - Instance->Log(DEBUG, "PQstatus: CONNECTION_SETENV: Negotiating environment-driven parameter settings."); - break; - - default: - Instance->Log(DEBUG, "PQstatus: ???"); - } - } - bool OnDataReady() { /* Always return true here, false would close the socket - we need to do that ourselves with the pgsql API */ - Instance->Log(DEBUG, "OnDataReady(): status = %s", StatusStr()); return DoEvent(); } bool OnWriteReady() { /* Always return true here, false would close the socket - we need to do that ourselves with the pgsql API */ - Instance->Log(DEBUG, "OnWriteReady(): status = %s", StatusStr()); return DoEvent(); } bool OnConnected() { - Instance->Log(DEBUG, "OnConnected(): status = %s", StatusStr()); return DoEvent(); } - void DelayReconnect() - { - ReconnectTimer* timer = new ReconnectTimer(Instance, this, us); - Instance->Timers->AddTimer(timer); - } + void DelayReconnect(); bool DoEvent() { @@ -792,15 +552,6 @@ class SQLConn : public EventHandler return ret; } - const char* StatusStr() - { - 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!"; - } - SQLerror DoQuery(SQLrequest &req) { if((status == WREAD) || (status == WWRITE)) @@ -813,23 +564,32 @@ class SQLConn : public EventHandler char* query; /* Pointer to the current end of query, where we append new stuff */ char* queryend; + /* Total length of the unescaped parameters */ - unsigned int paramlen; + unsigned long maxparamlen, paramcount; - paramlen = 0; + /* The length of the longest parameter */ + maxparamlen = 0; for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++) { - paramlen += i->size(); + if (i->size() > maxparamlen) + maxparamlen = i->size(); } + /* How many params are there in the query? */ + paramcount = count(req.query.q.c_str(), '?'); + + /* This stores copy of params to be inserted with using numbered params 1;3B*/ + ParamL paramscopy(req.query.p); + /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be. - * sizeofquery + (totalparamlength*2) + 1 + * sizeofquery + (maxtotalparamlength*2) + 1 * * The +1 is for null-terminating the string for PQsendQuery() */ - query = new char[req.query.q.length() + (paramlen*2) + 1]; + query = new char[req.query.q.length() + (maxparamlen*paramcount*2) + 1]; queryend = query; /* Okay, now we have a buffer large enough we need to start copying the query into it and escaping and substituting @@ -847,7 +607,53 @@ class SQLConn : public EventHandler * pointing at the right place. */ - if(req.query.p.size()) + /* Is it numbered parameter? + */ + + bool numbered; + numbered = false; + + /* Numbered parameter number :| + */ + unsigned int paramnum; + paramnum = 0; + + /* Let's check if it's a numbered param. And also calculate it's number. + */ + + while ((i < req.query.q.length() - 1) && (req.query.q[i+1] >= '0') && (req.query.q[i+1] <= '9')) + { + numbered = true; + ++i; + paramnum = paramnum * 10 + req.query.q[i] - '0'; + } + + if (paramnum > paramscopy.size() - 1) + { + /* index is out of range! + */ + numbered = false; + } + + if (numbered) + { + int error = 0; + size_t len = 0; + +#ifdef PGSQL_HAS_ESCAPECONN + len = PQescapeStringConn(sql, queryend, paramscopy[paramnum].c_str(), paramscopy[paramnum].length(), &error); +#else + len = PQescapeString (queryend, paramscopy[paramnum].c_str(), paramscopy[paramnum].length()); +#endif + if (error) + { + ServerInstance->Logs->Log("m_pgsql", DEBUG, "BUG: Apparently PQescapeStringConn() failed somehow...don't know how or what to do..."); + } + + /* Incremenet queryend to the end of the newly escaped parameter */ + queryend += len; + } + else if (req.query.p.size()) { int error = 0; size_t len = 0; @@ -859,11 +665,9 @@ class SQLConn : public EventHandler #endif if(error) { - Instance->Log(DEBUG, "Apparently PQescapeStringConn() failed somehow...don't know how or what to do..."); + ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: Apparently PQescapeStringConn() failed somehow...don't know how or what to do..."); } - Instance->Log(DEBUG, "Appended %d bytes of escaped string onto the query", len); - /* Incremenet queryend to the end of the newly escaped parameter */ queryend += len; @@ -872,7 +676,7 @@ class SQLConn : public EventHandler } else { - Instance->Log(DEBUG, "Found a substitution location but no parameter to substitute :|"); + ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: Found a substitution location but no parameter to substitute :|"); break; } } @@ -885,38 +689,33 @@ class SQLConn : public EventHandler /* Null-terminate the query */ *queryend = 0; - - Instance->Log(DEBUG, "Attempting to dispatch query: %s", query); - req.query.q = query; if(PQsendQuery(sql, query)) { - Instance->Log(DEBUG, "Dispatched query successfully"); qinprog = true; delete[] query; return SQLerror(); } else { - Instance->Log(DEBUG, "Failed to dispatch query: %s", PQerrorMessage(sql)); delete[] query; - return SQLerror(QSEND_FAIL, PQerrorMessage(sql)); + return SQLerror(SQL_QSEND_FAIL, PQerrorMessage(sql)); } } } - return SQLerror(BAD_CONN, "Can't query until connection is complete"); + return SQLerror(SQL_BAD_CONN, "Can't query until connection is complete"); } SQLerror Query(const SQLrequest &req) { - queue.push(req); + queue.push(new SQLrequest(req)); if(!qinprog && queue.totalsize()) { /* There's no query currently in progress, and there's queries in the queue. */ - SQLrequest& query = queue.front(); - return DoQuery(query); + SQLrequest* query = queue.front(); + return DoQuery(*query); } else { @@ -934,22 +733,20 @@ class SQLConn : public EventHandler return confhost; } - void Close() { - DoClose(); - } - - void DoClose() + void Close() { - Instance->Log(DEBUG,"SQLConn::Close"); - Instance->Log(DEBUG, "FD IS: %d", this->fd); - - if (!this->Instance->SE->DelFd(this)) + if (!ServerInstance->SE->DelFd(this)) { - Instance->Log(DEBUG, "PQsocket cant be removed from the socket engine!"); - } - else { - Instance->Log(DEBUG, "FD WAS REMOVED!"); + if (sql && PQstatus(sql) == CONNECTION_BAD) + { + ServerInstance->SE->DelFd(this, true); + } + else + { + ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: PQsocket cant be removed from socket engine!"); + } } + if(sql) { PQfinish(sql); @@ -961,46 +758,47 @@ class SQLConn : public EventHandler class ModulePgSQL : public Module { - private: + private: ConnMap connections; unsigned long currid; char* sqlsuccess; + ReconnectTimer* retimer; - public: - ModulePgSQL(InspIRCd* Me) - : Module::Module(Me), currid(0) + public: + ModulePgSQL() + : currid(0) { - ServerInstance->UseInterface("SQLutils"); + ServerInstance->Modules->UseInterface("SQLutils"); sqlsuccess = new char[strlen(SQLSUCCESS)+1]; strlcpy(sqlsuccess, SQLSUCCESS, strlen(SQLSUCCESS)); - if (!ServerInstance->PublishFeature("SQL", this)) + if (!ServerInstance->Modules->PublishFeature("SQL", this)) { - throw ModuleException("m_pgsql: Unable to publish feature 'SQL'"); + throw ModuleException("BUG: PgSQL Unable to publish feature 'SQL'"); } ReadConf(); - ServerInstance->PublishInterface("SQL", this); + ServerInstance->Modules->PublishInterface("SQL", this); + Implementation eventlist[] = { I_OnUnloadModule, I_OnRehash }; + ServerInstance->Modules->Attach(eventlist, this, 2); } virtual ~ModulePgSQL() { + if (retimer) + ServerInstance->Timers->DelTimer(retimer); ClearAllConnections(); delete[] sqlsuccess; - ServerInstance->UnpublishInterface("SQL", this); - ServerInstance->UnpublishFeature("SQL"); - ServerInstance->DoneWithInterface("SQLutils"); + ServerInstance->Modules->UnpublishInterface("SQL", this); + ServerInstance->Modules->UnpublishFeature("SQL"); + ServerInstance->Modules->DoneWithInterface("SQLutils"); } - void Implements(char* List) - { - List[I_OnUnloadModule] = List[I_OnRequest] = List[I_OnRehash] = List[I_OnUserRegister] = List[I_OnCheckReady] = List[I_OnUserDisconnect] = 1; - } - virtual void OnRehash(userrec* user, const std::string ¶meter) + virtual void OnRehash(User* user) { ReadConf(); } @@ -1017,7 +815,7 @@ class ModulePgSQL : public Module bool HostInConf(const SQLhost &h) { - ConfigReader conf(ServerInstance); + ConfigReader conf; for(int i = 0; i < conf.Enumerate("database"); i++) { SQLhost host; @@ -1038,12 +836,10 @@ class ModulePgSQL : public Module { ClearOldConnections(); - ConfigReader conf(ServerInstance); + ConfigReader conf; for(int i = 0; i < conf.Enumerate("database"); i++) { SQLhost host; - int ipvalid; - insp_inaddr blargle; host.id = conf.ReadValue("database", "id", i); host.host = conf.ReadValue("database", "hostname", i); @@ -1056,36 +852,7 @@ class ModulePgSQL : public Module if (HasHost(host)) continue; - ipvalid = insp_aton(host.host.c_str(), &blargle); - - if(ipvalid > 0) - { - /* The conversion succeeded, we were given an IP and we can give it straight to SQLConn */ - host.ip = host.host; - this->AddConn(host); - } - else if(ipvalid == 0) - { - /* Conversion failed, assume it's a host */ - SQLresolver* resolver; - - try - { - bool cached; - resolver = new SQLresolver(this, ServerInstance, host, cached); - ServerInstance->AddResolver(resolver, cached); - } - catch(...) - { - /* THE WORLD IS COMING TO AN END! */ - ServerInstance->Log(DEBUG, "Couldn't make a SQLresolver..this connection is gonna diiiiiie...actually we just won't create it"); - } - } - else - { - /* Invalid address family, die horribly. */ - ServerInstance->Log(DEBUG, "insp_aton failed returning -1, oh noes."); - } + this->AddConn(host); } } @@ -1096,7 +863,7 @@ class ModulePgSQL : public Module { if (!HostInConf(iter->second->GetConfHost())) { - DELETE(iter->second); + delete iter->second; safei = iter; --iter; connections.erase(safei); @@ -1110,7 +877,7 @@ class ModulePgSQL : public Module while ((i = connections.begin()) != connections.end()) { connections.erase(i); - DELETE(i->second); + delete i->second; } } @@ -1118,14 +885,13 @@ class ModulePgSQL : public Module { if (HasHost(hi)) { - ServerInstance->Log(DEFAULT, "WARNING: A pgsql connection with id: %s already exists, possibly due to DNS delay. Aborting connection attempt.", hi.id.c_str()); + ServerInstance->Logs->Log("m_pgsql",DEFAULT, "WARNING: A pgsql connection with id: %s already exists. Aborting connection attempt.", hi.id.c_str()); return; } SQLConn* newconn; - /* The conversion succeeded, we were given an IP and we can give it straight to SQLConn */ - newconn = new SQLConn(ServerInstance, this, hi); + newconn = new SQLConn(this, hi); connections.insert(std::make_pair(hi.id, newconn)); } @@ -1136,41 +902,32 @@ class ModulePgSQL : public Module { if (conn == iter->second) { - DELETE(iter->second); + delete iter->second; connections.erase(iter); break; } } - ReadConf(); + retimer = new ReconnectTimer(this); + ServerInstance->Timers->AddTimer(retimer); } - virtual char* OnRequest(Request* request) + void OnRequest(Request& request) { - if(strcmp(SQLREQID, request->GetId()) == 0) + if(strcmp(SQLREQID, request.id) == 0) { - SQLrequest* req = (SQLrequest*)request; + SQLrequest* req = (SQLrequest*)&request; ConnMap::iterator iter; - - 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()); - if((iter = connections.find(req->dbid)) != connections.end()) { /* Execute query */ req->id = NewID(); req->error = iter->second->Query(*req); - - return (req->error.Id() == NO_ERROR) ? sqlsuccess : NULL; } else { - req->error.Id(BAD_DBID); - return NULL; + req->error.Id(SQL_BAD_DBID); } } - - ServerInstance->Log(DEBUG, "Got unsupported API version string: %s", request->GetId()); - - return NULL; } virtual void OnUnloadModule(Module* mod, const std::string& name) @@ -1197,45 +954,18 @@ class ModulePgSQL : public Module virtual Version GetVersion() { - return Version(1, 1, 0, 0, VF_VENDOR|VF_SERVICEPROVIDER, API_VERSION); + return Version("PostgreSQL Service Provider module for all other m_sql* modules, uses v2 of the SQL API", VF_VENDOR|VF_SERVICEPROVIDER, API_VERSION); } }; -/* move this here to use AddConn, rather that than having the whole - * module above SQLConn, since this is buggin me right now :/ - */ -void SQLresolver::OnLookupComplete(const std::string &result, unsigned int ttl, bool cached) -{ - host.ip = result; - ((ModulePgSQL*)mod)->AddConn(host); - ((ModulePgSQL*)mod)->ClearOldConnections(); -} - void ReconnectTimer::Tick(time_t time) { - ((ModulePgSQL*)mod)->ReconnectConn(conn); + ((ModulePgSQL*)mod)->ReadConf(); } - -class ModulePgSQLFactory : public ModuleFactory +void SQLConn::DelayReconnect() { - public: - ModulePgSQLFactory() - { - } - - ~ModulePgSQLFactory() - { - } - - virtual Module * CreateModule(InspIRCd* Me) - { - return new ModulePgSQL(Me); - } -}; - - -extern "C" void * init_module( void ) -{ - return new ModulePgSQLFactory; + ((ModulePgSQL*)us)->ReconnectConn(this); } + +MODULE_INIT(ModulePgSQL)