X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fextra%2Fm_pgsql.cpp;h=85d092241d2074627e42d00f0ae9beb60684724b;hb=b4a174ee9c32d62ea6bf010e837e8c5b1c3d36a3;hp=d72256a5ffa52961e49f931f1b94d44d6c3b2528;hpb=dac672cf303ce44dc5f877a5f9f7e5aee64b95e1;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/extra/m_pgsql.cpp b/src/modules/extra/m_pgsql.cpp index d72256a5f..e1db996c8 100644 --- a/src/modules/extra/m_pgsql.cpp +++ b/src/modules/extra/m_pgsql.cpp @@ -1,241 +1,94 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2007 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * Copyright (C) 2016 Adam + * Copyright (C) 2015 Daniel Vassdal + * Copyright (C) 2013, 2016-2020 Sadie Powell + * Copyright (C) 2012-2015 Attila Molnar + * Copyright (C) 2012 Robby + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2009 Uli Schlachter + * Copyright (C) 2008 Thomas Stagner + * Copyright (C) 2007, 2009-2010 Craig Edwards + * Copyright (C) 2007, 2009 Dennis Friis + * Copyright (C) 2007 Robin Burchell + * Copyright (C) 2006 Oliver Lupton * - * This program is free but copyrighted software; see - * the file COPYING for details. + * 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 +/// $CompilerFlags: -Iexecute("pg_config --includedir" "POSTGRESQL_INCLUDE_DIR") +/// $LinkerFlags: -Lexecute("pg_config --libdir" "POSTGRESQL_LIBRARY_DIR") -lpq + +/// $PackageInfo: require_system("arch") postgresql-libs +/// $PackageInfo: require_system("centos") postgresql-devel +/// $PackageInfo: require_system("darwin") postgresql +/// $PackageInfo: require_system("debian") libpq-dev +/// $PackageInfo: require_system("ubuntu") libpq-dev -#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 */ -/* $ModDep: m_sqlv2.h */ - -/* 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 :\ +#include +#include +#include "modules/sql.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. */ /* Forward declare, so we can have the typedef neatly at the top */ class SQLConn; +class ModulePgSQL; -typedef std::map ConnMap; +typedef insp::flat_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 - * RREAD, Resetting and wants read event - * RWRITE, Resetting and wants write event - */ -enum SQLstatus { CREAD, CWRITE, WREAD, WWRITE, RREAD, RWRITE }; - -/** SQLhost::GetDSN() - Overload to return correct DSN for PostgreSQL - */ -std::string SQLhost::GetDSN() +enum SQLstatus { - std::ostringstream conninfo("connect_timeout = '2'"); - - if (ip.length()) - conninfo << " hostaddr = '" << ip << "'"; - - if (port) - conninfo << " port = '" << port << "'"; + // The connection has died. + DEAD, - if (name.length()) - conninfo << " dbname = '" << name << "'"; + // Connecting and wants read event. + CREAD, - if (user.length()) - conninfo << " user = '" << user << "'"; + // Connecting and wants write event. + CWRITE, - if (pass.length()) - conninfo << " password = '" << pass << "'"; + // Connected/working and wants read event. + WREAD, - if (ssl) - conninfo << " sslmode = 'require'"; - - return conninfo.str(); -} + // Connected/working and wants write event. + WWRITE +}; -/** Used to resolve sql server hostnames - */ -class SQLresolver : public Resolver +class ReconnectTimer : public Timer { private: - SQLhost host; - Module* mod; + ModulePgSQL* 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) + ReconnectTimer(ModulePgSQL* m) : Timer(5, false), mod(m) { } - - virtual void OnLookupComplete(const std::string &result, unsigned int ttl); - - virtual void OnError(ResolverError e, const std::string &errormessage) - { - ServerInstance->Log(DEBUG, "DNS lookup failed (%s), dying horribly", errormessage.c_str()); - } + bool Tick(time_t TIME) CXX11_OVERRIDE; }; -/** 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 +struct QueueItem { -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); - } - } - } - } + SQL::Query* c; + std::string q; + QueueItem(SQL::Query* C, const std::string& Q) : c(C), q(Q) {} }; /** PgSQLresult is a subclass of the mostly-pure-virtual class SQLresult. @@ -245,1054 +98,549 @@ private: * data is passes to the module nearly as directly as if it was using the API directly itself. */ -class PgSQLresult : public SQLresult +class PgSQLresult : public SQL::Result { PGresult* res; int currentrow; int rows; - int cols; + std::vector colnames; - 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) + void getColNames() + { + colnames.resize(PQnfields(res)); + for(unsigned int i=0; i < colnames.size(); i++) + { + colnames[i] = PQfname(res, i); + } + } + public: + PgSQLresult(PGresult* result) : res(result), currentrow(0) { rows = PQntuples(res); - cols = PQnfields(res); - - //ServerInstance->Log(DEBUG, "Created new PgSQL result; %d rows, %d columns, %s affected", rows, cols, PQcmdTuples(res)); + if (!rows) + rows = ConvToNum(PQcmdTuples(res)); } ~PgSQLresult() { - /* If we allocated these, free them... */ - if(fieldlist) - DELETE(fieldlist); - - if(fieldmap) - DELETE(fieldmap); - PQclear(res); } - virtual int Rows() + int Rows() CXX11_OVERRIDE { - if(!cols && !rows) - { - return atoi(PQcmdTuples(res)); - } - else - { - return rows; - } + return rows; } - virtual int Cols() + void GetCols(std::vector& result) CXX11_OVERRIDE { - return PQnfields(res); - } - - virtual std::string ColName(int column) - { - char* name = PQfname(res, column); - - return (name) ? name : ""; + if (colnames.empty()) + getColNames(); + result = colnames; } - virtual int ColNum(const std::string &column) + bool HasColumn(const std::string& column, size_t& index) CXX11_OVERRIDE { - int n = PQfnumber(res, column.c_str()); + if (colnames.empty()) + getColNames(); - if(n == -1) + for (size_t i = 0; i < colnames.size(); ++i) { - throw SQLbadColName(); - } - else - { - return n; + if (colnames[i] == column) + { + index = i; + return true; + } } + return false; } - virtual SQLfield GetValue(int row, int column) + SQL::Field GetValue(int row, int column) { char* v = PQgetvalue(res, row, column); + if (!v || PQgetisnull(res, row, column)) + return SQL::Field(); - if(v) - { - return SQLfield(std::string(v, PQgetlength(res, row, column)), PQgetisnull(res, row, column)); - } - else - { - //ServerInstance->Log(DEBUG, "PQgetvalue returned a null pointer..nobody wants to tell us what this means"); - throw SQLbadColName(); - } + return SQL::Field(std::string(v, PQgetlength(res, row, column))); } - virtual SQLfieldList& GetRow() + bool GetRow(SQL::Row& result) CXX11_OVERRIDE { - /* In an effort to reduce overhead we don't actually allocate the list - * until the first time it's needed...so... - */ - if(fieldlist) - { - fieldlist->clear(); - } - else + if (currentrow >= PQntuples(res)) + return false; + int ncols = PQnfields(res); + + for(int i = 0; i < ncols; i++) { - fieldlist = new SQLfieldList; + result.push_back(GetValue(currentrow, i)); } + currentrow++; - if(currentrow < PQntuples(res)) - { - int cols = PQnfields(res); + return true; + } +}; - for(int i = 0; i < cols; i++) - { - fieldlist->push_back(GetValue(currentrow, i)); - } +/** SQLConn represents one SQL session. + */ +class SQLConn : public SQL::Provider, public EventHandler +{ + 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 */ - currentrow++; - } + SQLConn(Module* Creator, ConfigTag* tag) + : SQL::Provider(Creator, tag->getString("id")) + , conf(tag) + , sql(NULL) + , status(CWRITE) + , qinprog(NULL, "") + { + if (!DoConnect()) + DelayReconnect(); + } - return *fieldlist; + CullResult cull() CXX11_OVERRIDE + { + this->SQL::Provider::cull(); + ServerInstance->Modules->DelService(*this); + return this->EventHandler::cull(); } - virtual SQLfieldMap& GetRowMap() + ~SQLConn() { - /* In an effort to reduce overhead we don't actually allocate the map - * until the first time it's needed...so... - */ - if(fieldmap) + SQL::Error err(SQL::BAD_DBID); + if (qinprog.c) { - fieldmap->clear(); + qinprog.c->OnError(err); + delete qinprog.c; } - else + for(std::deque::iterator i = queue.begin(); i != queue.end(); i++) { - fieldmap = new SQLfieldMap; + SQL::Query* q = i->c; + q->OnError(err); + delete q; } - - if(currentrow < PQntuples(res)) - { - int cols = PQnfields(res); - - for(int i = 0; i < cols; i++) - { - fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i))); - } - - currentrow++; - } - - return *fieldmap; + Close(); } - virtual SQLfieldList* GetRowPtr() + void OnEventHandlerRead() CXX11_OVERRIDE { - SQLfieldList* fl = new SQLfieldList; - - if(currentrow < PQntuples(res)) - { - int cols = PQnfields(res); - - for(int i = 0; i < cols; i++) - { - fl->push_back(GetValue(currentrow, i)); - } - - currentrow++; - } - - return fl; + DoEvent(); } - virtual SQLfieldMap* GetRowMapPtr() + void OnEventHandlerWrite() CXX11_OVERRIDE { - SQLfieldMap* fm = new SQLfieldMap; - - if(currentrow < PQntuples(res)) - { - int cols = PQnfields(res); - - for(int i = 0; i < cols; i++) - { - fm->insert(std::make_pair(ColName(i), GetValue(currentrow, i))); - } - - currentrow++; - } - - return fm; + DoEvent(); } - virtual void Free(SQLfieldMap* fm) + void OnEventHandlerError(int errornum) CXX11_OVERRIDE { - DELETE(fm); + DelayReconnect(); } - virtual void Free(SQLfieldList* fl) + std::string GetDSN() { - DELETE(fl); - } -}; - -/** 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 -{ -private: - 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: - - /* 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(InspIRCd* SI, Module* self, const SQLhost& hostinfo); - - ~SQLConn(); - - bool DoConnect(); - - virtual void Close(); - - void DoClose(); - - bool DoPoll(); - - bool DoConnectedPoll(); - - bool DoResetPoll(); - - void ShowStatus(); - - virtual bool OnDataReady(); - - virtual bool OnWriteReady(); - - virtual bool OnConnected(); - - bool DoEvent(); + std::ostringstream conninfo("connect_timeout = '5'"); + std::string item; - bool Reconnect(); + if (conf->readString("host", item)) + conninfo << " host = '" << item << "'"; - const char* StatusStr(); + if (conf->readString("port", item)) + conninfo << " port = '" << item << "'"; - SQLerror DoQuery(SQLrequest &req); + if (conf->readString("name", item)) + conninfo << " dbname = '" << item << "'"; - SQLerror Query(const SQLrequest &req); + if (conf->readString("user", item)) + conninfo << " user = '" << item << "'"; - void OnUnloadModule(Module* mod); + if (conf->readString("pass", item)) + conninfo << " password = '" << item << "'"; - const SQLhost GetConfHost(); -}; - -SQLConn::SQLConn(InspIRCd* SI, Module* self, const SQLhost& hi) -: InspSocket::InspSocket(SI), confhost(hi), us(self), sql(NULL), status(CWRITE), qinprog(false) -{ - idle = this->Instance->Time(); - this->ClosePending = false; + if (conf->getBool("ssl")) + conninfo << " sslmode = 'require'"; + else + conninfo << " sslmode = 'disable'"; - if(!this->DoConnect()) - { - Instance->Log(DEFAULT, "WARNING: Could not connect to database with id: " + ConvToStr(hi.id)); + return conninfo.str(); } -} -SQLConn::~SQLConn() -{ - DoClose(); -} - -bool SQLConn::DoConnect() -{ - if(!(sql = PQconnectStart(confhost.GetDSN().c_str()))) + bool HandleConnectError(const char* reason) { - Instance->Log(DEBUG, "Couldn't allocate PGconn structure, aborting: %s", PQerrorMessage(sql)); - DoClose(); + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Could not connect to the \"%s\" database: %s", + GetId().c_str(), reason); return false; } - if(PQstatus(sql) == CONNECTION_BAD) + bool DoConnect() { - Instance->Log(DEBUG, "PQconnectStart failed: %s", PQerrorMessage(sql)); - DoClose(); - return false; - } + sql = PQconnectStart(GetDSN().c_str()); + if (!sql) + return HandleConnectError("PQconnectStart returned NULL"); - ShowStatus(); + if(PQstatus(sql) == CONNECTION_BAD) + return HandleConnectError("connection status is bad"); - if(PQsetnonblocking(sql, 1) == -1) - { - Instance->Log(DEBUG, "Couldn't set connection nonblocking: %s", PQerrorMessage(sql)); - DoClose(); - return false; - } + if(PQsetnonblocking(sql, 1) == -1) + return HandleConnectError("unable to mark fd as non-blocking"); - /* OK, we've initalised the connection, now to get it hooked into the socket engine - * and then start polling it. - */ + /* OK, we've initialised the connection, now to get it hooked into the socket engine + * and then start polling it. + */ + SetFd(PQsocket(sql)); + if(!HasFd()) + return HandleConnectError("PQsocket returned an invalid fd"); - //ServerInstance->Log(DEBUG, "Old DNS socket: %d", this->fd); - this->fd = PQsocket(sql); - Instance->Log(DEBUG, "New SQL socket: %d", this->fd); + if (!SocketEngine::AddFd(this, FD_WANT_NO_WRITE | FD_WANT_NO_READ)) + return HandleConnectError("could not add the pgsql socket to the socket engine"); - if(this->fd <= -1) - { - Instance->Log(DEBUG, "PQsocket says we have an invalid FD: %d", this->fd); - DoClose(); - return false; - } - - this->state = I_CONNECTING; - if (!this->Instance->SE->AddFd(this)) - { - Instance->Log(DEBUG, "A PQsocket cant be added to the socket engine!"); - DoClose(); - return false; - } + /* Socket all hooked into the engine, now to tell PgSQL to start connecting */ + if (!DoPoll()) + return HandleConnectError("could not poll the connection state"); - /* Socket all hooked into the engine, now to tell PgSQL to start connecting */ - - return DoPoll(); -} - -void SQLConn::Close() { - DoClose(); -} - -bool SQLConn::DoPoll() -{ - switch(PQconnectPoll(sql)) - { - case PGRES_POLLING_WRITING: - //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_WRITING"); - WantWrite(); - status = CWRITE; - return DoPoll(); - case PGRES_POLLING_READING: - //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_READING"); - status = CREAD; - return true; - case PGRES_POLLING_FAILED: - //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_FAILED: %s", PQerrorMessage(sql)); - return false; - case PGRES_POLLING_OK: - //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_OK"); - status = WWRITE; - return DoConnectedPoll(); - default: - //ServerInstance->Log(DEBUG, "PGconnectPoll: wtf?"); - return true; + return true; } -} -bool SQLConn::DoConnectedPoll() -{ - if(!qinprog && queue.totalsize()) + bool DoPoll() { - /* There's no query currently in progress, and there's queries in the queue. */ - SQLrequest& query = queue.front(); - DoQuery(query); + switch(PQconnectPoll(sql)) + { + case PGRES_POLLING_WRITING: + SocketEngine::ChangeEventMask(this, FD_WANT_POLL_WRITE | FD_WANT_NO_READ); + status = CWRITE; + return true; + case PGRES_POLLING_READING: + SocketEngine::ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); + status = CREAD; + return true; + case PGRES_POLLING_FAILED: + SocketEngine::ChangeEventMask(this, FD_WANT_NO_READ | FD_WANT_NO_WRITE); + status = DEAD; + return false; + case PGRES_POLLING_OK: + SocketEngine::ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); + status = WWRITE; + DoConnectedPoll(); + return true; + default: + return true; + } } - if(PQconsumeInput(sql)) + void DoConnectedPoll() { - 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(); - - if(PQisBusy(sql)) +restart: + while (qinprog.q.empty() && !queue.empty()) { - //ServerInstance->Log(DEBUG, "Still busy processing command though"); + /* There's no query currently in progress, and there's queries in the queue. */ + DoQuery(queue.front()); + queue.pop_front(); } - 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); - - /* 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)) + if (PQconsumeInput(sql)) + { + if (PQisBusy(sql)) { - PQclear(result); - result = temp; + /* Nothing happens here */ } - - if(to) + else if (qinprog.c) { - /* ..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; - - Instance->Log(DEBUG, "Got result, status code: %s; error message: %s", PQresStatus(PQresultStatus(result)), PQresultErrorMessage(result)); + /* 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)) { 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 */ + { + SQL::Error err(SQL::QREPLY_FAIL, PQresultErrorMessage(result)); + qinprog.c->OnError(err); + break; + } + default: + /* Other values are not errors */ + qinprog.c->OnResult(reply); } - reply.Send(); - - /* PgSQLresult's destructor will free the PGresult */ + delete qinprog.c; + qinprog = QueueItem(NULL, ""); + goto restart; } 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... - */ - 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.q.clear(); } - - qinprog = false; - queue.pop(); - DoConnectedPoll(); } else { - Instance->Log(DEBUG, "Eh!? We just got a read event, and connection isn't busy..but no result :("); + /* 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; - } - 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. - */ - Instance->Log(DEBUG, "PQconsumeInput failed: %s", PQerrorMessage(sql)); - Reconnect(); - return true; - } -} - -bool SQLConn::DoResetPoll() -{ - switch(PQresetPoll(sql)) - { - case PGRES_POLLING_WRITING: - //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_WRITING"); - WantWrite(); - status = CWRITE; - return DoPoll(); - case PGRES_POLLING_READING: - //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_READING"); - 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"); - status = WWRITE; - return DoConnectedPoll(); - default: - //ServerInstance->Log(DEBUG, "PGresetPoll: wtf?"); - return true; - } -} - -void SQLConn::ShowStatus() -{ - switch(PQstatus(sql)) - { - 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 SQLConn::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 SQLConn::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 SQLConn::OnConnected() -{ - Instance->Log(DEBUG, "OnConnected(): status = %s", StatusStr()); - - return DoEvent(); -} - -bool SQLConn::Reconnect() -{ - Instance->Log(DEBUG, "Initiating reconnect"); + void DelayReconnect(); - if(PQresetStart(sql)) - { - /* Successfully initiatied database reconnect, - * set flags so PQresetPoll() will be called appropriately - */ - status = RWRITE; - qinprog = false; - return true; - } - else - { - Instance->Log(DEBUG, "Failed to initiate reconnect...fun"); - return false; - } -} - -bool SQLConn::DoEvent() -{ - bool ret; - - if((status == CREAD) || (status == CWRITE)) - { - ret = DoPoll(); - } - else if((status == RREAD) || (status == RWRITE)) - { - ret = DoResetPoll(); - } - else + void DoEvent() { - ret = DoConnectedPoll(); + if((status == CREAD) || (status == CWRITE)) + { + DoPoll(); + } + else if (status == WREAD || status == WWRITE) + { + DoConnectedPoll(); + } } - switch(PQflush(sql)) + void Submit(SQL::Query *req, const std::string& q) CXX11_OVERRIDE { - case -1: - Instance->Log(DEBUG, "Error flushing write queue: %s", PQerrorMessage(sql)); - break; - case 0: - Instance->Log(DEBUG, "Successfully flushed write queue (or there was nothing to write)"); - break; - case 1: - Instance->Log(DEBUG, "Not all of the write queue written, triggering write event so we can have another go"); - WantWrite(); - break; + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Executing PostgreSQL query: " + q); + if (qinprog.q.empty()) + { + DoQuery(QueueItem(req,q)); + } + else + { + // wait your turn. + queue.push_back(QueueItem(req,q)); + } } - return ret; -} - -const char* SQLConn::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 SQLConn::DoQuery(SQLrequest &req) -{ - if((status == WREAD) || (status == WWRITE)) + void Submit(SQL::Query *req, const std::string& q, const SQL::ParamList& p) CXX11_OVERRIDE { - if(!qinprog) + std::string res; + unsigned int param = 0; + for(std::string::size_type i = 0; i < q.length(); i++) { - /* 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++) - { - paramlen += i->size(); - } - - /* 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++) + if (q[i] != '?') + res.push_back(q[i]); + else { - if(req.query.q[i] == '?') + if (param < p.size()) { - /* 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->Log(DEBUG, "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; - - /* Remove the parameter we just substituted in */ - req.query.p.pop_front(); - } - else - { - Instance->Log(DEBUG, "Found a substitution location but no parameter to substitute :|"); - break; - } - } - else - { - *queryend = req.query.q[i]; - queryend++; + std::string parm = p[param++]; + std::vector buffer(parm.length() * 2 + 1); + int error; + size_t escapedsize = PQescapeStringConn(sql, &buffer[0], parm.data(), parm.length(), &error); + if (error) + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "BUG: Apparently PQescapeStringConn() failed"); + res.append(&buffer[0], escapedsize); } } + } + Submit(req, res); + } - /* 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(); - } + void Submit(SQL::Query *req, const std::string& q, const SQL::ParamMap& p) CXX11_OVERRIDE + { + std::string res; + for(std::string::size_type i = 0; i < q.length(); i++) + { + if (q[i] != '$') + res.push_back(q[i]); else { - Instance->Log(DEBUG, "Failed to dispatch query: %s", PQerrorMessage(sql)); - delete[] query; - return SQLerror(QSEND_FAIL, PQerrorMessage(sql)); + std::string field; + i++; + while (i < q.length() && isalnum(q[i])) + field.push_back(q[i++]); + i--; + + SQL::ParamMap::const_iterator it = p.find(field); + if (it != p.end()) + { + std::string parm = it->second; + std::vector buffer(parm.length() * 2 + 1); + int error; + size_t escapedsize = PQescapeStringConn(sql, &buffer[0], parm.data(), parm.length(), &error); + if (error) + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "BUG: Apparently PQescapeStringConn() failed"); + res.append(&buffer[0], escapedsize); + } } } + Submit(req, res); } - return SQLerror(BAD_CONN, "Can't query until connection is complete"); -} - -SQLerror SQLConn::Query(const SQLrequest &req) -{ - queue.push(req); - - if(!qinprog && queue.totalsize()) + void DoQuery(const QueueItem& req) { - /* There's no query currently in progress, and there's queries in the queue. */ - SQLrequest& query = queue.front(); - return DoQuery(query); + if (status != WREAD && status != WWRITE) + { + // whoops, not connected... + SQL::Error err(SQL::BAD_CONN); + req.c->OnError(err); + delete req.c; + return; + } + + if(PQsendQuery(sql, req.q.c_str())) + { + qinprog = req; + } + else + { + SQL::Error err(SQL::QSEND_FAIL, PQerrorMessage(sql)); + req.c->OnError(err); + delete req.c; + } } - else + + void Close() { - return SQLerror(); - } -} + status = DEAD; -void SQLConn::OnUnloadModule(Module* mod) -{ - queue.PurgeModule(mod); -} + if (HasFd() && SocketEngine::HasFd(GetFd())) + SocketEngine::DelFd(this); -const SQLhost SQLConn::GetConfHost() -{ - return confhost; -} + if(sql) + { + PQfinish(sql); + sql = NULL; + } + } +}; class ModulePgSQL : public Module { -private: - + public: ConnMap connections; - ConnMap deadconnections; - unsigned long currid; - char* sqlsuccess; + ReconnectTimer* retimer; -public: - ModulePgSQL(InspIRCd* Me) - : Module::Module(Me), currid(0) + ModulePgSQL() + : retimer(NULL) { - ServerInstance->UseInterface("SQLutils"); - - sqlsuccess = new char[strlen(SQLSUCCESS)+1]; - - strlcpy(sqlsuccess, SQLSUCCESS, strlen(SQLSUCCESS)); - - if (!ServerInstance->PublishFeature("SQL", this)) - { - throw ModuleException("m_pgsql: Unable to publish feature 'SQL'"); - } - - ReadConf(); - - ServerInstance->PublishInterface("SQL", this); } - virtual ~ModulePgSQL() + ~ModulePgSQL() { + delete retimer; ClearAllConnections(); - delete[] sqlsuccess; - ServerInstance->UnpublishInterface("SQL", this); - ServerInstance->UnpublishFeature("SQL"); - ServerInstance->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) + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE { ReadConf(); } - bool HasHost(const SQLhost &host) - { - ClearDeadConnections(); - for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++) - { - if (host == iter->second->GetConfHost()) - return true; - } - return false; - } - - bool HostInConf(const SQLhost &h) - { - ClearDeadConnections(); - 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", i); - if (h == host) - return true; - } - return false; - } - void ReadConf() { - ClearDeadConnections(); - ConfigReader conf(ServerInstance); - - for(int i = 0; i < conf.Enumerate("database"); i++) + ConnMap conns; + ConfigTagList tags = ServerInstance->Config->ConfTags("database"); + for(ConfigIter i = tags.first; i != tags.second; i++) { - SQLhost host; - int ipvalid; - insp_inaddr blargle; - - 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", i); - - if (HasHost(host)) + if (!stdalgo::string::equalsci(i->second->getString("module"), "pgsql")) 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) + std::string id = i->second->getString("id"); + ConnMap::iterator curr = connections.find(id); + if (curr == connections.end()) { - /* Conversion failed, assume it's a host */ - SQLresolver* resolver; - - try + SQLConn* conn = new SQLConn(this, i->second); + if (conn->status != DEAD) { - bool cached; - resolver = new SQLresolver(this, ServerInstance, host, cached); - if (!cached) - ServerInstance->AddResolver(resolver); - else - delete resolver; - } - 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"); + conns.insert(std::make_pair(id, conn)); + ServerInstance->Modules->AddService(*conn); } + // If the connection is dead it has already been queued for culling + // at the end of the main loop so we don't need to delete it here. } else { - /* Invalid address family, die horribly. */ - ServerInstance->Log(DEBUG, "insp_aton failed returning -1, oh noes."); - } - } - ClearOldConnections(); - } - - void ClearOldConnections() - { - ClearDeadConnections(); - 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); + conns.insert(*curr); + connections.erase(curr); } } + ClearAllConnections(); + conns.swap(connections); } void ClearAllConnections() { - ClearDeadConnections(); - ConnMap::iterator iter; - while ((iter = connections.begin()) != connections.end()) + for(ConnMap::iterator i = connections.begin(); i != connections.end(); i++) { - connections.erase(iter); - delete iter->second; + i->second->cull(); + delete i->second; } + connections.clear(); } - void ClearDeadConnections() + void OnUnloadModule(Module* mod) CXX11_OVERRIDE { - ConnMap::iterator di; - while ((di = deadconnections.begin()) != deadconnections.end()) + SQL::Error err(SQL::BAD_DBID); + for(ConnMap::iterator i = connections.begin(); i != connections.end(); i++) { - ConnMap::iterator iter = connections.find(di->first); - if (iter != connections.end()) + SQLConn* conn = i->second; + if (conn->qinprog.c && conn->qinprog.c->creator == mod) { - connections.erase(iter); + conn->qinprog.c->OnError(err); + delete conn->qinprog.c; + conn->qinprog.c = NULL; } - deadconnections.erase(di); - } - } - - void AddDeadConn(std::string id, SQLConn* conn) - { - deadconnections[id] = conn; - } - - void AddConn(const SQLhost& hi) - { - 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()); - 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)); - } - - virtual char* OnRequest(Request* request) - { - if(strcmp(SQLREQID, request->GetId()) == 0) - { - 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 + std::deque::iterator j = conn->queue.begin(); + while (j != conn->queue.end()) { - req->error.Id(BAD_DBID); - return NULL; + SQL::Query* q = j->c; + if (q->creator == mod) + { + q->OnError(err); + delete q; + j = conn->queue.erase(j); + } + else + j++; } } - - ServerInstance->Log(DEBUG, "Got unsupported API version string: %s", request->GetId()); - - return NULL; } - virtual void OnUnloadModule(Module* mod, const std::string& name) + Version GetVersion() CXX11_OVERRIDE { - /* 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); - } - } - - unsigned long NewID() - { - if (currid+1 == 0) - currid++; - - return ++currid; - } - - virtual Version GetVersion() - { - return Version(1, 1, 0, 0, VF_VENDOR|VF_SERVICEPROVIDER, API_VERSION); + return Version("Provides the ability for SQL modules to query a PostgreSQL database.", VF_VENDOR); } }; -/* 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 ReconnectTimer::Tick(time_t time) { - host.ip = result; - ((ModulePgSQL*)mod)->AddConn(host); - ((ModulePgSQL*)mod)->ClearOldConnections(); + mod->retimer = NULL; + mod->ReadConf(); + delete this; + return false; } -/* move this here too, to use AddDeadConn */ -void SQLConn::DoClose() +void SQLConn::DelayReconnect() { - Instance->Log(DEBUG,"SQLConn::Close"); + status = DEAD; + ModulePgSQL* mod = (ModulePgSQL*)(Module*)creator; - if (!this->Instance->SE->DelFd(this)) + 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) { - Instance->Log(DEBUG, "PQsocket cant be removed from the socket engine!"); + mod->retimer = new ReconnectTimer(mod); + ServerInstance->Timers.AddTimer(mod->retimer); } - this->fd = -1; - this->state = I_ERROR; - this->OnError(I_ERR_SOCKET); - this->ClosePending = true; - - if(sql) - { - PQfinish(sql); - sql = NULL; - } - - ((ModulePgSQL*)us)->AddDeadConn(confhost.id, this); } -class ModulePgSQLFactory : public ModuleFactory -{ - public: - ModulePgSQLFactory() - { - } - - ~ModulePgSQLFactory() - { - } - - virtual Module * CreateModule(InspIRCd* Me) - { - return new ModulePgSQL(Me); - } -}; - - -extern "C" void * init_module( void ) -{ -// PQregisterThreadLock(pgthreadlock_t(1)); - return new ModulePgSQLFactory; -} +MODULE_INIT(ModulePgSQL)