/usr/local/include/openssl/pqueue.h:73: error: ISO C++ does not support `long long'

[user/henk/code/inspircd.git] / src / modules / extra / m_mysql.cpp

diff --git a/src/modules/extra/m_mysql.cpp b/src/modules/extra/m_mysql.cpp
index fc804d50ef9dcbf91faa6068ed41eeefafd37542..1feb3b02b90f7779b96a5383f6101efc57daa894 100644 (file)
--- a/src/modules/extra/m_mysql.cpp
+++ b/src/modules/extra/m_mysql.cpp
@@ -11,14 +11,12 @@
  * ---------------------------------------------------
  */
 
-#include <stdio.h>
-#include <string>
+#include "inspircd.h"
 #include <mysql.h>
 #include <pthread.h>
 #include "users.h"
 #include "channels.h"
 #include "modules.h"
-#include "inspircd.h"
 #include "m_sqlv2.h"
 
 /* VERSION 2 API: With nonblocking (threaded) requests */
@@ -27,6 +25,7 @@
 /* $CompileFlags: exec("mysql_config --include") */
 /* $LinkerFlags: exec("mysql_config --libs_r") rpath("mysql_config --libs_r") */
 /* $ModDep: m_sqlv2.h */
+/* $NoPedantic */
 
 /* THE NONBLOCKING MYSQL API!
  * 
@@ -576,6 +575,30 @@ void LoadDatabases(ConfigReader* conf, InspIRCd* ServerInstance)
        ConnectDatabases(ServerInstance);
 }
 
+char FindCharId(const std::string &id)
+{
+       char i = 1;
+       for (ConnMap::iterator iter = Connections.begin(); iter != Connections.end(); ++iter, ++i)
+       {
+               if (iter->first == id)
+               {
+                       return i;
+               }
+       }
+       return 0;
+}
+
+ConnMap::iterator GetCharId(char id)
+{
+       char i = 1;
+       for (ConnMap::iterator iter = Connections.begin(); iter != Connections.end(); ++iter, ++i)
+       {
+               if (i == id)
+                       return iter;
+       }
+       return Connections.end();
+}
+
 void NotifyMainThread(SQLConnection* connection_with_new_result)
 {
        /* Here we write() to the socket the main thread has open
@@ -586,15 +609,23 @@ void NotifyMainThread(SQLConnection* connection_with_new_result)
         * thread, we can just use standard connect(), and we can
         * block if we like. We just send the connection id of the
         * connection back.
+        *
+        * NOTE: We only send a single char down the connection, this
+        * way we know it wont get a partial read at the other end if
+        * the system is especially congested (see bug #263).
+        * The function FindCharId translates a connection name into a
+        * one character id, and GetCharId translates a character id
+        * back into an iterator.
         */
-       send(QueueFD, connection_with_new_result->GetID().c_str(), connection_with_new_result->GetID().length()+1, 0);
+       char id = FindCharId(connection_with_new_result->GetID());
+       send(QueueFD, &id, 1, 0);
 }
 
 void* DispatcherThread(void* arg);
 
 /** Used by m_mysql to notify one thread when the other has a result
  */
-class Notifier : public InspSocket
+class Notifier : public BufferedSocket
 {
        insp_sockaddr sock_us;
        socklen_t uslen;
@@ -604,9 +635,9 @@ class Notifier : public InspSocket
 
        /* Create a socket on a random port. Let the tcp stack allocate us an available port */
 #ifdef IPV6
-       Notifier(InspIRCd* SI) : InspSocket(SI, "::1", 0, true, 3000)
+       Notifier(InspIRCd* SI) : BufferedSocket(SI, "::1", 0, true, 3000)
 #else
-       Notifier(InspIRCd* SI) : InspSocket(SI, "127.0.0.1", 0, true, 3000)
+       Notifier(InspIRCd* SI) : BufferedSocket(SI, "127.0.0.1", 0, true, 3000)
 #endif
        {
                uslen = sizeof(sock_us);
@@ -616,7 +647,7 @@ class Notifier : public InspSocket
                }
        }
 
-       Notifier(InspIRCd* SI, int newfd, char* ip) : InspSocket(SI, newfd, ip)
+       Notifier(InspIRCd* SI, int newfd, char* ip) : BufferedSocket(SI, newfd, ip)
        {
        }
 
@@ -639,13 +670,17 @@ class Notifier : public InspSocket
 
        virtual bool OnDataReady()
        {
-               char* data = this->Read();
-               ConnMap::iterator iter;
-
-               if (data && *data)
+               char data = 0;
+               /* NOTE: Only a single character is read so we know we
+                * cant get a partial read. (We've been told that theres
+                * data waiting, so we wont ever get EAGAIN)
+                * The function GetCharId translates a single character
+                * back into an iterator.
+                */
+               if (Instance->SE->Recv(this, &data, 1, 0) > 0)
                {
-                       /* We expect to be sent a null terminated string */
-                       if((iter = Connections.find(data)) != Connections.end())
+                       ConnMap::iterator iter = GetCharId(data);
+                       if (iter != Connections.end())
                        {
                                /* Lock the mutex, send back the data */
                                pthread_mutex_lock(&results_mutex);
@@ -655,8 +690,11 @@ class Notifier : public InspSocket
                                pthread_mutex_unlock(&results_mutex);
                                return true;
                        }
+                       /* No error, but unknown id */
+                       return true;
                }
 
+               /* Erk, error on descriptor! */
                return false;
        }
 };
@@ -676,7 +714,7 @@ class ModuleSQL : public Module
        ModuleSQL(InspIRCd* Me)
        : Module::Module(Me), rehashing(false)
        {
-               ServerInstance->UseInterface("SQLutils");
+               ServerInstance->Modules->UseInterface("SQLutils");
 
                Conf = new ConfigReader(ServerInstance);
                PublicServerInstance = ServerInstance;
@@ -693,24 +731,24 @@ class ModuleSQL : public Module
                        throw ModuleException("m_mysql: Failed to create dispatcher thread: " + std::string(strerror(errno)));
                }
 
-               if (!ServerInstance->PublishFeature("SQL", this))
+               if (!ServerInstance->Modules->PublishFeature("SQL", this))
                {
                        /* Tell worker thread to exit NOW */
                        giveup = true;
                        throw ModuleException("m_mysql: Unable to publish feature 'SQL'");
                }
 
-               ServerInstance->PublishInterface("SQL", this);
+               ServerInstance->Modules->PublishInterface("SQL", this);
        }
 
        virtual ~ModuleSQL()
        {
                giveup = true;
                ClearAllConnections();
-               DELETE(Conf);
-               ServerInstance->UnpublishInterface("SQL", this);
-               ServerInstance->UnpublishFeature("SQL");
-               ServerInstance->DoneWithInterface("SQLutils");
+               delete Conf;
+               ServerInstance->Modules->UnpublishInterface("SQL", this);
+               ServerInstance->Modules->UnpublishFeature("SQL");
+               ServerInstance->Modules->DoneWithInterface("SQLutils");
        }
 
 
@@ -759,7 +797,7 @@ class ModuleSQL : public Module
                return NULL;
        }
 
-       virtual void OnRehash(userrec* user, const std::string &parameter)
+       virtual void OnRehash(User* user, const std::string &parameter)
        {
                rehashing = true;
        }
@@ -848,29 +886,4 @@ void* DispatcherThread(void* arg)
        return NULL;
 }
 
-
-// stuff down here is the module-factory stuff. For basic modules you can ignore this.
-
-class ModuleSQLFactory : public ModuleFactory
-{
- public:
-       ModuleSQLFactory()
-       {
-       }
-       
-       ~ModuleSQLFactory()
-       {
-       }
-       
-       virtual Module * CreateModule(InspIRCd* Me)
-       {
-               return new ModuleSQL(Me);
-       }
-       
-};
-
-
-extern "C" void * init_module( void )
-{
-       return new ModuleSQLFactory;
-}
+MODULE_INIT(ModuleSQL)