X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fextra%2Fm_pgsql.cpp;h=fb282fb98a5e35e3ae6d66d2e7e2fa5223c4a2a8;hb=b07868e77c0527642ed72bce84bf5895bf921e87;hp=e16f38e5990fc5aa508c22d8d3866841ac9b99ae;hpb=7e709ca6554dfb530521ecbe6943d8578392d46b;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/extra/m_pgsql.cpp b/src/modules/extra/m_pgsql.cpp index e16f38e59..fb282fb98 100644 --- a/src/modules/extra/m_pgsql.cpp +++ b/src/modules/extra/m_pgsql.cpp @@ -2,47 +2,37 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd is copyright (C) 2002-2004 ChatSpike-Dev. - * E-mail: - * - * - * - * - * Written by Craig Edwards, Craig McLure, and others. + * InspIRCd: (C) 2002-2008 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ +#include "inspircd.h" +#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" /* $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 */ +/* $ModDep: m_sqlv2.h */ + + +/* 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; @@ -52,476 +42,943 @@ 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 }; +enum SQLstatus { CREAD, CWRITE, WREAD, WWRITE, RREAD, RWRITE }; -class SQLerror +/** SQLhost::GetDSN() - Overload to return correct DSN for PostgreSQL + */ +std::string SQLhost::GetDSN() { -public: - std::string err; + std::ostringstream conninfo("connect_timeout = '2'"); + + if (ip.length()) + conninfo << " hostaddr = '" << ip << "'"; + + if (port) + conninfo << " port = '" << port << "'"; + + if (name.length()) + conninfo << " dbname = '" << name << "'"; + + if (user.length()) + conninfo << " user = '" << user << "'"; - SQLerror(const std::string &s) - : err(s) + if (pass.length()) + conninfo << " password = '" << pass << "'"; + + if (ssl) + { + conninfo << " sslmode = 'require'"; + } + else { + conninfo << " sslmode = 'disable'"; } + + return conninfo.str(); +} + +class ReconnectTimer : public Timer +{ + private: + Module* mod; + public: + ReconnectTimer(InspIRCd* SI, Module* m) + : Timer(5, SI->Time(), false), mod(m) + { + } + virtual void Tick(time_t TIME); }; -/** 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. + +/** Used to resolve sql server hostnames */ +class SQLresolver : public Resolver +{ + private: + SQLhost host; + Module* 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, int resultnum = 0); + + virtual void OnError(ResolverError e, const std::string &errormessage) + { + ServerInstance->Logs->Log("m_pgsql",DEBUG, "PgSQL: DNS lookup failed (%s), dying horribly", errormessage.c_str()); + } +}; -class SQLConn : public InspSocket +/** 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 PgSQLresult : public SQLresult { -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 */ + PGresult* res; + int currentrow; + int rows; + int cols; + SQLfieldList* fieldlist; + SQLfieldMap* fieldmap; public: + 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); + } + + ~PgSQLresult() + { + /* If we allocated these, free them... */ + if(fieldlist) + delete fieldlist; + + if(fieldmap) + delete fieldmap; + + PQclear(res); + } + + virtual int Rows() + { + if(!cols && !rows) + { + return atoi(PQcmdTuples(res)); + } + else + { + return rows; + } + } + + virtual int Cols() + { + return PQnfields(res); + } + + virtual std::string ColName(int column) + { + char* name = PQfname(res, column); - /* This class should only ever be created inside this module, using this constructor, so we don't have to worry about the default ones */ + return (name) ? name : ""; + } + + virtual int ColNum(const std::string &column) + { + int n = PQfnumber(res, column.c_str()); + + if(n == -1) + { + throw SQLbadColName(); + } + else + { + return n; + } + } - 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) + virtual SQLfield GetValue(int row, int column) { - 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()); + char* v = PQgetvalue(res, row, column); - /* Some of this could be reviewed, unsure if I need to fill 'host' etc... - * just copied this over from the InspSocket constructor. + if(v) + { + return SQLfield(std::string(v, PQgetlength(res, row, column)), PQgetisnull(res, row, column)); + } + else + { + throw SQLbadColName(); + } + } + + virtual SQLfieldList& GetRow() + { + /* In an effort to reduce overhead we don't actually allocate the list + * until the first time it's needed...so... */ - 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; + if(fieldlist) + { + fieldlist->clear(); } else { - log(DEBUG,"No need to resolve %s", this->host); - strlcpy(this->IP, this->host, MAXBUF); - - if(!this->DoConnect()) + fieldlist = new SQLfieldList; + } + + if(currentrow < PQntuples(res)) + { + int ncols = PQnfields(res); + + for(int i = 0; i < ncols; i++) { - throw ModuleException("Connect failed"); + fieldlist->push_back(GetValue(currentrow, i)); } + + currentrow++; } - - exit(-1); + + return *fieldlist; } - - ~SQLConn() + + virtual SQLfieldMap& GetRowMap() { - + /* In an effort to reduce overhead we don't actually allocate the map + * until the first time it's needed...so... + */ + if(fieldmap) + { + fieldmap->clear(); + } + else + { + fieldmap = new SQLfieldMap; + } + + if(currentrow < PQntuples(res)) + { + int ncols = PQnfields(res); + + for(int i = 0; i < ncols; i++) + { + fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i))); + } + + currentrow++; + } + + return *fieldmap; } - - bool DoResolve() - { - log(DEBUG, "Checking for DNS lookup result"); - - if(this->dns.HasResult()) + + virtual SQLfieldList* GetRowPtr() + { + SQLfieldList* fl = new SQLfieldList; + + if(currentrow < PQntuples(res)) { - std::string res_ip = dns.GetResultIP(); - - if(res_ip.length()) + int ncols = PQnfields(res); + + for(int i = 0; i < ncols; i++) { - 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(); + fl->push_back(GetValue(currentrow, i)); } - else + + currentrow++; + } + + return fl; + } + + virtual SQLfieldMap* GetRowMapPtr() + { + SQLfieldMap* fm = new SQLfieldMap; + + if(currentrow < PQntuples(res)) + { + int ncols = PQnfields(res); + + for(int i = 0; i < ncols; i++) { - log(DEBUG, "DNS lookup failed, dying horribly"); - Close(); - return false; + fm->insert(std::make_pair(ColName(i), GetValue(currentrow, i))); } + + currentrow++; } - else + + return fm; + } + + virtual void Free(SQLfieldMap* fm) + { + delete fm; + } + + virtual void Free(SQLfieldList* fl) + { + delete fl; + } +}; + +/** SQLConn represents one SQL session. + */ +class SQLConn : public EventHandler +{ + private: + InspIRCd* Instance; + SQLhost confhost; /* The entry */ + Module* us; /* Pointer to the SQL provider itself */ + 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 */ + 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) + { + idle = this->Instance->Time(); + if(!DoConnect()) { - log(DEBUG, "No result for lookup yet!"); - return true; + Instance->Logs->Log("m_pgsql",DEFAULT, "WARNING: Could not connect to database with id: " + ConvToStr(hi.id)); + DelayReconnect(); } - - exit(-1); } - bool DoConnect() + ~SQLConn() { - log(DEBUG, "SQLConn::DoConnect()"); - - if(!(sql = PQconnectStart(MkInfoStr().c_str()))) + Close(); + } + + virtual void HandleEvent(EventType et, int errornum) + { + switch (et) { - log(DEBUG, "Couldn't allocate PGconn structure, aborting: %s", PQerrorMessage(sql)); - Close(); - return false; + case EVENT_READ: + OnDataReady(); + break; + + case EVENT_WRITE: + OnWriteReady(); + break; + + case EVENT_ERROR: + DelayReconnect(); + break; + + default: + break; } - + } + + bool DoConnect() + { + if(!(sql = PQconnectStart(confhost.GetDSN().c_str()))) + 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 (!this->Instance->SE->AddFd(this)) { - log(DEBUG, "PQsocket says we have an invalid FD: %d", this->fd); - Close(); + Instance->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() - { - this->fd = -1; - this->state = I_ERROR; - this->OnError(I_ERR_SOCKET); - this->ClosePending = true; - log(DEBUG,"SQLConn::Close"); - - if(sql) - { - PQfinish(sql); - sql = NULL; - } - - return; - } - + bool DoPoll() { switch(PQconnectPoll(sql)) { case PGRES_POLLING_WRITING: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_WRITING"); + Instance->SE->WantWrite(this); status = CWRITE; - DoPoll(); - break; + return true; case PGRES_POLLING_READING: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_READING"); status = CREAD; - break; + return true; case PGRES_POLLING_FAILED: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_FAILED: %s", PQerrorMessage(sql)); - Close(); return false; case PGRES_POLLING_OK: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_OK"); status = WWRITE; - Query("SELECT * FROM rawr"); - break; + return DoConnectedPoll(); default: - log(DEBUG, "PGconnectPoll: wtf?"); - break; + return true; } - - return true; } - - void ShowStatus() + + bool DoConnectedPoll() { - switch(PQstatus(sql)) + if(!qinprog && queue.totalsize()) { - 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; - + /* There's no query currently in progress, and there's queries in the queue. */ + SQLrequest& query = queue.front(); + DoQuery(query); + } + + if(PQconsumeInput(sql)) + { + /* We just read stuff from the server, that counts as it being alive + * so update the idle-since time :p + */ + idle = this->Instance->Time(); + + if (PQisBusy(sql)) + { + /* Nothing happens here */ + } + else if (qinprog) + { + /* Grab the request we're processing */ + SQLrequest& query = queue.front(); + + /* Get a pointer to the module we're about to return the result to */ + Module* to = query.GetSource(); + + /* 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; + } + + if(to) + { + /* ..and the 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; + + switch(PQresultStatus(result)) + { + case PGRES_EMPTY_QUERY: + case PGRES_BAD_RESPONSE: + case PGRES_FATAL_ERROR: + reply.error.Id(QREPLY_FAIL); + reply.error.Str(PQresultErrorMessage(result)); + default:; + /* No action, other values are not errors */ + } + + reply.Send(); + + /* PgSQLresult's destructor will free the PGresult */ + } + else + { + /* If the client module is unloaded partway through a query then the provider will set + * 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... + */ + PQclear(result); + } + qinprog = false; + queue.pop(); + DoConnectedPoll(); + } + return true; + } + 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(); + return true; + } + } + + bool DoResetPoll() + { + switch(PQresetPoll(sql)) + { + case PGRES_POLLING_WRITING: + Instance->SE->WantWrite(this); + status = CWRITE; + return DoPoll(); + case PGRES_POLLING_READING: + status = CREAD; + return true; + case PGRES_POLLING_FAILED: + return false; + case PGRES_POLLING_OK: + status = WWRITE; + return DoConnectedPoll(); default: - log(DEBUG, "PQstatus: ???"); + return true; } } - - virtual bool OnDataReady() + + 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 OnConnected() + + bool OnWriteReady() { - log(DEBUG, "OnConnected(): status = %s", StatusStr()); - + /* Always return true here, false would close the socket - we need to do that ourselves with the pgsql API */ return DoEvent(); } - + + bool OnConnected() + { + return DoEvent(); + } + + void DelayReconnect(); + bool DoEvent() { + bool ret; + if((status == CREAD) || (status == CWRITE)) { - DoPoll(); + ret = DoPoll(); + } + else if((status == RREAD) || (status == RWRITE)) + { + ret = DoResetPoll(); } else { - if(PQconsumeInput(sql)) + ret = DoConnectedPoll(); + } + return ret; + } + + SQLerror DoQuery(SQLrequest &req) + { + if((status == WREAD) || (status == WWRITE)) + { + if(!qinprog) { - log(DEBUG, "PQconsumeInput succeeded"); - - if(PQisBusy(sql)) + /* Parse the command string and dispatch it */ + + /* Pointer to the buffer we screw around with substitution in */ + 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; + + paramlen = 0; + + for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++) { - log(DEBUG, "Still busy processing command though"); + paramlen += i->size(); } - else + + /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be. + * sizeofquery + (totalparamlength*2) + 1 + * + * The +1 is for null-terminating the string for PQsendQuery() + */ + + query = new char[req.query.q.length() + (paramlen*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 + * the parameters into it... + */ + + for(unsigned int i = 0; i < req.query.q.length(); i++) { - log(DEBUG, "Looks like we have a result to process!"); - - while(PGresult* result = PQgetResult(sql)) + if(req.query.q[i] == '?') { - 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++) + /* We found a place to substitute..what fun. + * Use the PgSQL calls to escape and write the + * escaped string onto the end of our query buffer, + * then we "just" need to make sure queryend is + * pointing at the right place. + */ + + if(req.query.p.size()) + { + int error = 0; + size_t len = 0; + +#ifdef PGSQL_HAS_ESCAPECONN + len = PQescapeStringConn(sql, queryend, req.query.p.front().c_str(), req.query.p.front().length(), &error); +#else + len = PQescapeString (queryend, req.query.p.front().c_str(), req.query.p.front().length()); +#endif + if(error) + { + Instance->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; + + /* Remove the parameter we just substituted in */ + req.query.p.pop_front(); + } + else { - log(DEBUG, "Column name: %s (%d)", PQfname(result, i)); + Instance->Logs->Log("m_pgsql",DEBUG, "BUG: Found a substitution location but no parameter to substitute :|"); + break; } - - PQclear(result); + } + else + { + *queryend = req.query.q[i]; + queryend++; } } - } - else - { - log(DEBUG, "PQconsumeInput failed: %s", PQerrorMessage(sql)); + + /* Null-terminate the query */ + *queryend = 0; + req.query.q = query; + + if(PQsendQuery(sql, query)) + { + qinprog = true; + delete[] query; + return SQLerror(); + } + else + { + delete[] query; + return SQLerror(QSEND_FAIL, PQerrorMessage(sql)); + } } } + return SQLerror(BAD_CONN, "Can't query until connection is complete"); + } - return true; - } - - 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() - { - 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!"; - } - - bool Query(const std::string &query) + SQLerror Query(const SQLrequest &req) { - if((status == WREAD) || (status == WWRITE)) + queue.push(req); + + if(!qinprog && queue.totalsize()) { - if(PQsendQuery(sql, query.c_str())) + /* There's no query currently in progress, and there's queries in the queue. */ + SQLrequest& query = queue.front(); + return DoQuery(query); + } + else + { + return SQLerror(); + } + } + + void OnUnloadModule(Module* mod) + { + queue.PurgeModule(mod); + } + + const SQLhost GetConfHost() + { + return confhost; + } + + void Close() { + if (!this->Instance->SE->DelFd(this)) + { + if (sql && PQstatus(sql) == CONNECTION_BAD) { - log(DEBUG, "Dispatched query: %s", query.c_str()); - return true; + this->Instance->SE->DelFd(this, true); } else { - log(DEBUG, "Failed to dispatch query: %s", PQerrorMessage(sql)); - return false; + Instance->Logs->Log("m_pgsql",DEBUG, "BUG: PQsocket cant be removed from socket engine!"); } } - log(DEBUG, "Can't query until connection is complete"); - return false; + if(sql) + { + PQfinish(sql); + sql = NULL; + } + } + +}; + +class ModulePgSQL : public Module +{ + private: + ConnMap connections; + unsigned long currid; + char* sqlsuccess; + ReconnectTimer* retimer; + + public: + ModulePgSQL(InspIRCd* Me) + : Module::Module(Me), currid(0) + { + ServerInstance->Modules->UseInterface("SQLutils"); + + sqlsuccess = new char[strlen(SQLSUCCESS)+1]; + + strlcpy(sqlsuccess, SQLSUCCESS, strlen(SQLSUCCESS)); + + if (!ServerInstance->Modules->PublishFeature("SQL", this)) + { + throw ModuleException("BUG: PgSQL Unable to publish feature 'SQL'"); + } + + ReadConf(); + + ServerInstance->Modules->PublishInterface("SQL", this); + Implementation eventlist[] = { I_OnUnloadModule, I_OnRequest, I_OnRehash, I_OnUserRegister, I_OnCheckReady, I_OnUserDisconnect }; + ServerInstance->Modules->Attach(eventlist, this, 6); } - virtual void OnClose() + virtual ~ModulePgSQL() { - /* Close PgSQL connection */ + if (retimer) + ServerInstance->Timers->DelTimer(retimer); + ClearAllConnections(); + delete[] sqlsuccess; + ServerInstance->Modules->UnpublishInterface("SQL", this); + ServerInstance->Modules->UnpublishFeature("SQL"); + ServerInstance->Modules->DoneWithInterface("SQLutils"); } - virtual void OnError(InspSocketError e) + + virtual void OnRehash(User* user, const std::string ¶meter) { - /* Unsure if we need this, we should be reading/writing via the PgSQL API rather than the insp one... */ + ReadConf(); } - - virtual void OnTimeout() + + bool HasHost(const SQLhost &host) { - /* Unused, I think */ + for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++) + { + if (host == iter->second->GetConfHost()) + return true; + } + return false; } - -}; -class ModulePgSQL : public Module -{ -private: - Server* Srv; - ConnMap connections; + bool HostInConf(const SQLhost &h) + { + ConfigReader conf(ServerInstance); + for(int i = 0; i < conf.Enumerate("database"); i++) + { + SQLhost host; + host.id = conf.ReadValue("database", "id", i); + host.host = conf.ReadValue("database", "hostname", i); + host.port = conf.ReadInteger("database", "port", i, true); + host.name = conf.ReadValue("database", "name", i); + host.user = conf.ReadValue("database", "username", i); + host.pass = conf.ReadValue("database", "password", i); + host.ssl = conf.ReadFlag("database", "ssl", "0", i); + if (h == host) + return true; + } + return false; + } -public: - ModulePgSQL(Server* Me) - : Module::Module(Me), Srv(Me) + void ReadConf() { - 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(""); + ClearOldConnections(); + + ConfigReader conf(ServerInstance); + for(int i = 0; i < conf.Enumerate("database"); i++) + { + SQLhost host; + int ipvalid; + + host.id = conf.ReadValue("database", "id", i); + host.host = conf.ReadValue("database", "hostname", i); + host.port = conf.ReadInteger("database", "port", i, true); + host.name = conf.ReadValue("database", "name", i); + host.user = conf.ReadValue("database", "username", i); + host.pass = conf.ReadValue("database", "password", i); + host.ssl = conf.ReadFlag("database", "ssl", "0", i); + + if (HasHost(host)) + continue; + +#ifdef IPV6 + if (strchr(host.host.c_str(),':')) + { + in6_addr blargle; + ipvalid = inet_pton(AF_INET6, host.host.c_str(), &blargle); + } + else +#endif + { + in_addr blargle; + ipvalid = inet_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! */ + } + } + else + { + /* Invalid address family, die horribly. */ + ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: insp_aton failed returning -1, oh noes."); + } + } } - void Implements(char* List) + void ClearOldConnections() { - List[I_OnRehash] = List[I_OnUserRegister] = List[I_OnCheckReady] = List[I_OnUserDisconnect] = 1; + ConnMap::iterator iter,safei; + for (iter = connections.begin(); iter != connections.end(); iter++) + { + if (!HostInConf(iter->second->GetConfHost())) + { + delete iter->second; + safei = iter; + --iter; + connections.erase(safei); + } + } } - virtual void OnRehash(const std::string ¶meter) + void ClearAllConnections() { - 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++) + ConnMap::iterator i; + while ((i = connections.begin()) != connections.end()) { - DELETE(iter->second); + connections.erase(i); + delete i->second; } - - /* Empty out our list of connections */ - connections.clear(); + } - for(int i = 0; i < conf.Enumerate("database"); i++) + void AddConn(const SQLhost& hi) + { + if (HasHost(hi)) { - 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 Version GetVersion() + ServerInstance->Logs->Log("m_pgsql",DEFAULT, "WARNING: A pgsql connection with id: %s already exists, possibly due to DNS delay. 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); + + connections.insert(std::make_pair(hi.id, newconn)); + } + + void ReconnectConn(SQLConn* conn) { - return Version(1, 0, 0, 0, VF_VENDOR|VF_SERVICEPROVIDER); + for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++) + { + if (conn == iter->second) + { + delete iter->second; + connections.erase(iter); + break; + } + } + retimer = new ReconnectTimer(ServerInstance, this); + ServerInstance->Timers->AddTimer(retimer); } - - virtual ~ModulePgSQL() + + virtual const char* OnRequest(Request* request) { - } -}; + if(strcmp(SQLREQID, request->GetId()) == 0) + { + SQLrequest* req = (SQLrequest*)request; + ConnMap::iterator iter; + if((iter = connections.find(req->dbid)) != connections.end()) + { + /* Execute query */ + req->id = NewID(); + req->error = iter->second->Query(*req); -class ModulePgSQLFactory : public ModuleFactory -{ - public: - ModulePgSQLFactory() + return (req->error.Id() == NO_ERROR) ? sqlsuccess : NULL; + } + else + { + req->error.Id(BAD_DBID); + return NULL; + } + } + return NULL; + } + + virtual void OnUnloadModule(Module* mod, const std::string& name) { + /* When a module unloads we have to check all the pending queries for all our connections + * and set the Module* specifying where the query came from to NULL. If the query has already + * been dispatched then when it is processed it will be dropped if the pointer is NULL. + * + * If the queries we find are not already being executed then we can simply remove them immediately. + */ + for(ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++) + { + iter->second->OnUnloadModule(mod); + } } - - ~ModulePgSQLFactory() + + unsigned long NewID() { + if (currid+1 == 0) + currid++; + + return ++currid; } - - virtual Module * CreateModule(Server* Me) + + virtual Version GetVersion() { - return new ModulePgSQL(Me); + return Version(1, 2, 0, 0, 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, int resultnum) +{ + if (!resultnum) + { + host.ip = result; + ((ModulePgSQL*)mod)->AddConn(host); + ((ModulePgSQL*)mod)->ClearOldConnections(); + } +} + +void ReconnectTimer::Tick(time_t time) +{ + ((ModulePgSQL*)mod)->ReadConf(); +} -extern "C" void * init_module( void ) +void SQLConn::DelayReconnect() { - return new ModulePgSQLFactory; + ((ModulePgSQL*)us)->ReconnectConn(this); } + +MODULE_INIT(ModulePgSQL)