Changeset 2838 for vidalia/trunk/src

Timestamp:

07/06/08 18:43:48 (5 months ago)

Author:

edmanm

Message:

OK, story time: So, Qt really doesn't like it if you try to send data on a
socket in one thread and read data from it in another thread, even if you do
your locking correctly. Touching the socket in a thread other than the one in
which it was instantiated == death. I started working on a patch that does
away with threads and blocking I/O and simply uses Qt's signals and slots for
dealing with socket operations asynchronously from the main thread. This patch
got really big (already 3000+ lines and I'm not yet done) and isn't something
we want to do when we're trying to put out a 'stable' Vidalia bundle. We'll save
that patch for the next version (or start playing the stable/dev branch game?).

So, here's a hack much like what was removed in r2580, except this actually
works with Qt 4.4. The basic idea is to post an event to the control socket,
which will get delivered to the socket in the correct thread. The event tells
the socket what to send, and the main thread waits for the result of the send.
Sucky, huh?

Location:

vidalia/trunk/src/torcontrol

Files:

• CMakeLists.txt (modified) (1 diff)
• controlconnection.cpp (modified) (6 diffs)
• controlconnection.h (modified) (3 diffs)
• controlsocket.cpp (modified) (4 diffs)
• controlsocket.h (modified) (1 diff)

vidalia/trunk/src/torcontrol/CMakeLists.txt

@@ -29 +29 @@
   routerdescriptor.cpp
   routerstatus.cpp
+  sendcommandevent.cpp
   serverstatusevent.cpp
   stream.cpp

vidalia/trunk/src/torcontrol/controlconnection.cpp

@@ -35 +35 @@
   _status = Unset;
   _sock = 0;
+  _sendWaiter = new SendCommandEvent::SendWaiter();
 }
 
@@ -42 +43 @@
   /* Exit the event loop */
   exit();
-  /* Wait for the thread to finish. */
+  /* Wait for the thread to finish */
   wait();
+  /* Clean up after the send waiter */
+  delete _sendWaiter;
 }
 
@@ -201 +204 @@
                         ControlReply &reply, QString *errmsg)
 {
-  ReceiveWaiter w;
   bool result = false;
   QString errstr;
-  
-  _connMutex.lock();
-  if (!_sock) {
-    _connMutex.unlock();
-    return err(errmsg, tr("Control socket is not connected."));
-  }
-  if (_sock->sendCommand(cmd, &errstr)) {
+
+  _recvMutex.lock();
+  if (send(cmd, &errstr)) {
     /* Create and enqueue a new receive waiter */
-    _recvQueue.enqueue(&w);
-    _connMutex.unlock();
+    ReceiveWaiter *w = new ReceiveWaiter();
+    _recvQueue.enqueue(w);
+    _recvMutex.unlock();
+
+    /* Wait for and get the result, clean up, and return */
+    result = w->getResult(&reply, &errstr);
+    if (!result)
+      tc::error("Failed to receive control reply: %1").arg(errstr);
+    delete w;
   } else {
-    _connMutex.unlock();
     tc::error("Failed to send control command (%1): %2").arg(cmd.keyword())
                                                         .arg(errstr);
-    return err(errmsg, errstr);
-  }
-
-  /* Wait for and get the result, clean up, and return */
-  result = w.getResult(&reply, &errstr);
-  if (!result) {
-    tc::error("Failed to receive control reply: %1").arg(errstr);
-    if (errmsg)
-      *errmsg = errstr;
-  }
+    _recvMutex.unlock();
+  }
+
+  if (!result && errmsg)
+    *errmsg = errstr;
   return result;
 }
 
-/** Sends a control command to Tor and returns without waiting for the
- * response. */
+/** Sends a control command to Tor and returns true if the command was sent
+ * successfully. Otherwise, returns false and <b>*errmsg</b> (if supplied)
+ * will be set. */
 bool
 ControlConnection::send(const ControlCommand &cmd, QString *errmsg)
 {
-  QMutexLocker locker(&_connMutex);
-  if (!_sock)
+  _connMutex.lock();
+  if (!_sock || !_sock->isConnected()) {
+    _connMutex.unlock();
     return err(errmsg, tr("Control socket is not connected.")); 
-  return _sock->sendCommand(cmd, errmsg);
+  }
+  QCoreApplication::postEvent(_sock, new SendCommandEvent(cmd, _sendWaiter));
+  _connMutex.unlock();
+  
+  return _sendWaiter->getResult(errmsg);
 }
 
@@ -264 +269 @@
         tc::debug("Control Reply: %1").arg(reply.toString());
         
+        _recvMutex.lock();
         if (!_recvQueue.isEmpty()) {
           waiter = _recvQueue.dequeue();
           waiter->setResult(true, reply);
         }
+        _recvMutex.unlock();
       }
     } else {
@@ -312 +319 @@
   delete _connectTimer;
   _sock = 0;
+  _connMutex.unlock();
 
   /* If there are any messages waiting for a response, clear them. */
+  if (_sendWaiter->status() == SendCommandEvent::SendWaiter::Waiting)
+    _sendWaiter->setResult(false, tr("Control socket is not connected."));
+
+  _recvMutex.lock();
   while (!_recvQueue.isEmpty()) {
     ReceiveWaiter *w = _recvQueue.dequeue();
@@ -319 +331 @@
                  tr("Control socket is not connected."));
   }
-  _connMutex.unlock();
+  _recvMutex.unlock();
 }
 

vidalia/trunk/src/torcontrol/controlconnection.h

@@ -29 +29 @@
 #include "controlsocket.h"
 #include "torevents.h"
+#include "sendcommandevent.h"
 
 
@@ -99 +100 @@
   quint16 _port; /**< Port of Tor's control interface. */
   QMutex _connMutex; /**< Mutex around the control socket. */
+  QMutex _recvMutex; /**< Mutex around the queue of ReceiveWaiters. */
   QMutex _statusMutex; /**< Mutex around the connection status value. */
   int _connectAttempt; /**< How many times we've tried to connect to Tor while
@@ -123 +125 @@
   };
   QQueue<ReceiveWaiter *> _recvQueue; /**< Objects waiting for a reply. */
+  SendCommandEvent::SendWaiter* _sendWaiter;
 };
 

vidalia/trunk/src/torcontrol/controlsocket.cpp

@@ -19 +19 @@
 
 #include "controlsocket.h"
+#include "sendcommandevent.h"
 
 /** Timeout reads in 250ms. We can set this to a short value because if there
@@ -36 +37 @@
 {
   return (isValid() && state() == QAbstractSocket::ConnectedState);
+}
+
+/** Processes custom events sent to this object (e.g. SendCommandEvents) from
+ * other threads. */
+void
+ControlSocket::customEvent(QEvent *event)
+{
+  if (event->type() == CustomEventType::SendCommandEvent) {
+    SendCommandEvent *sce = dynamic_cast<SendCommandEvent *>(event);
+    if (! sce)
+      return;
+
+    QString errmsg;
+    bool result = sendCommand(sce->command(), &errmsg);
+    if (sce->waiter())
+      sce->waiter()->setResult(result, errmsg);
+    sce->accept();
+  }
 }
 
@@ -47 +66 @@
 bool
 ControlSocket::sendCommand(ControlCommand cmd, QString *errmsg)
-{
+{  
   if (!isConnected()) {
     return err(errmsg, tr("Control socket is not connected."));
@@ -126 +145 @@
   }
 
-  /* The implementation below is (loosely) based on the Java control library from Tor */
+  /* The implementation below is (loosely) based on the Java control library
+   * from Tor */
   do {
     /* Read a line of the response */

vidalia/trunk/src/torcontrol/controlsocket.h

@@ -45 +45 @@
   
 protected:
+  /** Processes custom events sent to this object (e.g. SendCommandEvents)
+   * from other threads. */
+  void customEvent(QEvent *event);
   /** Reads line data off the socket in chunks. */
   bool readLineData(QString &line, QString *errmsg = 0);