1 files changed, 38 insertions, 58 deletions

diff --git a/src/Net/Connection.cpp b/src/Net/Connection.cpp
index 2ccfddb..cf675c9 100644
--- a/src/Net/Connection.cpp
+++ b/src/Net/Connection.cpp
@@ -48,50 +48,40 @@ Connection::~Connection() {
 
   gnutls_certificate_free_credentials(x509_cred);
 
-  gl_rwlock_destroy(stateLock);
-  gl_lock_destroy(sendLock);
-  gl_lock_destroy(receiveLock);
-
   if(peer)
     delete peer;
 }
 
 void Connection::handshake() {
-  gl_rwlock_wrlock(stateLock);
-  if(state != CONNECT) {
-    gl_rwlock_unlock(stateLock);
+  boost::unique_lock<boost::shared_mutex> lock(stateLock);
+  if(state != CONNECT)
     return;
-  }
 
   state = HANDSHAKE;
-  gl_rwlock_unlock(stateLock);
+  lock.unlock();
 
   doHandshake();
 }
 
 void Connection::bye() {
-  gl_rwlock_wrlock(stateLock);
-  if(state != DISCONNECT) {
-    gl_rwlock_unlock(stateLock);
+  boost::unique_lock<boost::shared_mutex> lock(stateLock);
+  if(state != DISCONNECT)
     return;
-  }
 
   state = BYE;
-  gl_rwlock_unlock(stateLock);
+  lock.unlock();
 
   doBye();
 }
 
 void Connection::doHandshake() {
-  gl_rwlock_rdlock(stateLock);
-  if(state != HANDSHAKE) {
-    gl_rwlock_unlock(stateLock);
+  boost::shared_lock<boost::shared_mutex> lock(stateLock);
+  if(state != HANDSHAKE)
     return;
-  }
 
   int ret = gnutls_handshake(session);
   if(ret < 0) {
-    gl_rwlock_unlock(stateLock);
+    lock.unlock();
 
     if(ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
       updateEvents();
@@ -104,7 +94,7 @@ void Connection::doHandshake() {
   }
 
   state = CONNECTION_HEADER;
-  gl_rwlock_unlock(stateLock);
+  lock.unlock();
 
   connectionHeader();
 }
@@ -129,18 +119,16 @@ void Connection::doBye() {
 }
 
 void Connection::enterReceiveLoop() {
-  gl_rwlock_wrlock(stateLock);
+  boost::unique_lock<boost::shared_mutex> lock(stateLock);
 
-  if(!_isConnected() || _isDisconnecting()) {
-    gl_rwlock_unlock(stateLock);
+  if(!_isConnected() || _isDisconnecting())
     return;
-  }
 
   if(_isConnecting())
     ThreadManager::get()->pushWork(sigc::mem_fun(connectedSignal, &sigc::signal<void>::emit));
 
   state = PACKET_HEADER;
-  gl_rwlock_unlock(stateLock);
+  lock.unlock();
 
   rawReceive(sizeof(Packet::Data), sigc::mem_fun(this, &Connection::packetHeaderReceiveHandler));
 }
@@ -187,17 +175,15 @@ void Connection::doReceive() {
   if(!isConnected())
     return;
 
-  gl_lock_lock(receiveLock);
+  boost::unique_lock<boost::mutex> lock(receiveLock);
 
-  if(_receiveComplete()) {
-    gl_lock_unlock(receiveLock);
+  if(_receiveComplete())
     return;
-  }
 
   ssize_t ret = gnutls_record_recv(session, transR.data+transR.transmitted, transR.length-transR.transmitted);
 
   if(ret < 0) {
-    gl_lock_unlock(receiveLock);
+    lock.unlock();
     if(ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN)
       return;
 
@@ -213,14 +199,14 @@ void Connection::doReceive() {
     uint8_t *data = transR.data;
     transR.data = 0;
 
-    gl_lock_unlock(receiveLock);
+    lock.unlock();
 
     transR.notify(data, transR.length);
 
     delete [] data;
   }
   else {
-    gl_lock_unlock(receiveLock);
+    lock.unlock();
   }
 
   updateEvents();
@@ -232,18 +218,16 @@ bool Connection::rawReceive(unsigned long length,
   if(!isConnected())
     return false;
 
-  gl_lock_lock(receiveLock);
-  if(!_receiveComplete()) {
-    gl_lock_unlock(receiveLock);
+  boost::unique_lock<boost::mutex> lock(receiveLock);
+  if(!_receiveComplete())
     return false;
-  }
 
   transR.data = new uint8_t[length];
   transR.length = length;
   transR.transmitted = 0;
   transR.notify = notify;
 
-  gl_lock_unlock(receiveLock);
+  lock.unlock();
 
   updateEvents();
 
@@ -254,13 +238,13 @@ void Connection::doSend() {
   if(!isConnected())
     return;
 
-  gl_lock_lock(sendLock);
+  boost::unique_lock<boost::mutex> lock(sendLock);
   while(!_sendQueueEmpty()) {
     ssize_t ret = gnutls_record_send(session, transS.front().data+transS.front().transmitted,
         transS.front().length-transS.front().transmitted);
 
     if(ret < 0) {
-      gl_lock_unlock(sendLock);
+      lock.unlock();
 
       if(ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN)
         return;
@@ -278,7 +262,7 @@ void Connection::doSend() {
     }
   }
 
-  gl_lock_unlock(sendLock);
+  lock.unlock();
 
   updateEvents();
 }
@@ -290,9 +274,9 @@ bool Connection::rawSend(const uint8_t *data, unsigned long length) {
   Transmission trans = {length, 0, new uint8_t[length], sigc::slot<void,const void*,unsigned long>()};
   std::memcpy(trans.data, data, length);
 
-  gl_lock_lock(sendLock);
+  sendLock.lock();
   transS.push(trans);
-  gl_lock_unlock(sendLock);
+  sendLock.unlock();
 
   updateEvents();
 
@@ -333,9 +317,9 @@ void Connection::sendReceive(short events) {
 }
 
 bool Connection::send(const Packet &packet) {
-  gl_rwlock_rdlock(stateLock);
+  stateLock.lock_shared();
   bool err = (!_isConnected() || _isConnecting() || _isDisconnecting());
-  gl_rwlock_unlock(stateLock);
+  stateLock.unlock_shared();
 
   if(err)
     return false;
@@ -344,21 +328,19 @@ bool Connection::send(const Packet &packet) {
 }
 
 void Connection::disconnect() {
-  gl_rwlock_wrlock(stateLock);
-  if(!_isConnected() || _isDisconnecting()) {
-    gl_rwlock_unlock(stateLock);
+  boost::unique_lock<boost::shared_mutex> lock(stateLock);
+  if(!_isConnected() || _isDisconnecting())
     return;
-  }
 
   state = DISCONNECT;
 
-  gl_rwlock_unlock(stateLock);
+  lock.unlock();
 
   updateEvents();
 }
 
 void Connection::doDisconnect() {
-  gl_rwlock_wrlock(stateLock);
+  boost::unique_lock<boost::shared_mutex> lock(stateLock);
 
   if(_isConnected()) {
     FdManager::get()->unregisterFd(sock);
@@ -372,27 +354,25 @@ void Connection::doDisconnect() {
 
     state = DISCONNECTED;
   }
-
-  gl_rwlock_unlock(stateLock);
 }
 
 void Connection::updateEvents() {
-  gl_lock_lock(receiveLock);
+  receiveLock.lock();
   short events = (_receiveComplete() ? 0 : POLLIN);
-  gl_lock_unlock(receiveLock);
+  receiveLock.unlock();
 
-  gl_lock_lock(sendLock);
+  sendLock.lock();
   events |= (_sendQueueEmpty() ? 0 : POLLOUT);
-  gl_lock_unlock(sendLock);
+  sendLock.unlock();
 
-  gl_rwlock_rdlock(stateLock);
+  stateLock.lock_shared();
   if(state == HANDSHAKE || state == BYE)
     events = ((gnutls_record_get_direction(session) == 0) ? POLLIN : POLLOUT);
   else if(state == CONNECT || state == DISCONNECT)
     events |= POLLOUT;
 
   FdManager::get()->setFdEvents(sock, events);
-  gl_rwlock_unlock(stateLock);
+  stateLock.unlock_shared();
 }
 
 }