[FIX] qmake for signet updated

[FIX] All packets are transported with receiver information


git-svn-id: https://pokegen.svn.sourceforge.net/svnroot/pokegen/trunk@306 6ecfd1a5-f3ed-3746-8530-beee90d26b22

17 files changed, 410 insertions, 149 deletions

diff --git a/signet/CMakeLists.txt b/signet/CMakeLists.txt
index 996da19f..c043847a 100644
--- a/signet/CMakeLists.txt
+++ b/signet/CMakeLists.txt
@@ -20,6 +20,7 @@ SET(signet_HEADERS
     Global.h
     Room.h
     Server.h
+    ServerConnectionHandler.h
     Table.h
 )
 SET(signet_PROTOCOL_SRCS
@@ -36,6 +37,7 @@ SET(signet_SRCS
     ConnectionInfo.cpp
     Room.cpp
     Server.cpp
+    ServerConnectionHandler.cpp
     Table.cpp
 )
 
diff --git a/signet/ClientHandler.h b/signet/ClientHandler.h
index a7292619..8add6f54 100644
--- a/signet/ClientHandler.h
+++ b/signet/ClientHandler.h
@@ -39,11 +39,11 @@ class SIGNET_EXPORT ClientHandler : public QObject
     
     public:
         ClientHandler(QObject* parent);
+        
+        virtual QStringList receiveChain() const = 0;
     public slots:
         bool addClient(QTcpSocket* client);
         bool removeClient(QTcpSocket* client);
-        
-        virtual void packetReceived(QTcpSocket* client, Protocol::Packet* packet) = 0;
     protected:
         virtual QByteArray secretForClient(const QByteArray& id) const;
     private:
diff --git a/signet/Room.cpp b/signet/Room.cpp
index 6fbc3dcb..feb95bbc 100644
--- a/signet/Room.cpp
+++ b/signet/Room.cpp
@@ -29,6 +29,11 @@ Signet::Room::Room(const QString& name, Server* server) :
 {
 }
 
+QStringList Signet::Room::receiveChain() const
+{
+    return m_server->receiveChain() << QString("room-%1").arg(m_name);
+}
+
 void Signet::Room::packetReceived(QTcpSocket* client, Protocol::Packet* packet)
 {
     QString receiver = packet->received();
diff --git a/signet/Room.h b/signet/Room.h
index 2b3c7b74..57889869 100644
--- a/signet/Room.h
+++ b/signet/Room.h
@@ -37,6 +37,8 @@ class SIGNET_EXPORT Room : public ClientHandler
     
     public:
         Room(const QString& name, Server* server);
+        
+        QStringList receiveChain() const;
     public slots:
         void packetReceived(QTcpSocket* client, Protocol::Packet* packet);
     signals:
diff --git a/signet/Server.cpp b/signet/Server.cpp
index 8db9f09a..191ddd85 100644
--- a/signet/Server.cpp
+++ b/signet/Server.cpp
@@ -18,14 +18,9 @@
 // Header include
 #include "Server.h"
 
-// Protocol includes
-#include "protocol/ChallengeMediator.h"
-#include "protocol/ConnectMediator.h"
-#include "protocol/DisconnectMediator.h"
-#include "protocol/PacketMaker.h"
-
 // Signet includes
 #include "Room.h"
+#include "ServerConnectionHandler.h"
 
 // KDE includes
 #include <KConfig>
@@ -34,92 +29,35 @@
 
 // Qt includes
 #include <QtCore/QtGlobal>
+#include <QtCore/QMutexLocker>
 #include <QtCore/QTimer>
+#include <QtNetwork/QTcpServer>
 #include <QtNetwork/QTcpSocket>
 
 Signet::Server::Server(QObject* parent) :
-        ClientHandler(parent)
+        ClientHandler(parent),
+        m_server(new QTcpServer(this))
 {
     loadConfiguration();
     if (m_metaserverInfo.isValid())
         connectToMetaserver();
+    connect(m_server, SIGNAL(newConnection()), this, SLOT(newConnection()));
 }
 
-void Signet::Server::packetReceived(QTcpSocket* client, Protocol::Packet* packet)
+QStringList Signet::Server::receiveChain() const
 {
-    QString receiver = packet->received();
-    if (receiver.isEmpty())
-    {
-        switch (packet->type())
-        {
-            case Protocol::Packet::ConnectRequest:
-            {
-                Protocol::ConnectMediator mediator(client, Protocol::ConnectMediator::Server);
-                Protocol::ConnectMediator::Error error = mediator.replyToConnection();
-                switch (error)
-                {
-                    case Protocol::ConnectMediator::NoError:
-                        qDebug("Client connected from %s:%d", client->peerAddress().toString().toUtf8().constData(), client->peerPort());
-                        break;
-                    case Protocol::ConnectMediator::SocketError:
-                        qWarning("Socket error on connect");
-                        break;
-                    case Protocol::ConnectMediator::UnexpectedError:
-                        qWarning("Unexpected packet from %s:%d on connect", client->peerAddress().toString().toUtf8().constData(), client->peerPort());
-                        break;
-                    case Protocol::ConnectMediator::SideError:
-                        qCritical("Called the wrong method on connect");
-                        break;
-                }
-                break;
-            }
-            case Protocol::Packet::DisconnectRequest:
-            {
-                Protocol::DisconnectMediator mediator(client, Protocol::DisconnectMediator::Server);
-                Protocol::DisconnectMediator::Error error = mediator.replyToDisconnection();
-                switch (error)
-                {
-                    case Protocol::DisconnectMediator::NoError:
-                        qDebug("Client disconnected from %s:%d", client->peerAddress().toString().toUtf8().constData(), client->peerPort());
-                        break;
-                    case Protocol::DisconnectMediator::SocketError:
-                        qWarning("Socket error on disconnect");
-                        break;
-                    case Protocol::DisconnectMediator::UnexpectedError:
-                        qWarning("Unexpected packet from %s:%d on disconnect", client->peerAddress().toString().toUtf8().constData(), client->peerPort());
-                        break;
-                    case Protocol::DisconnectMediator::SideError:
-                        qCritical("Called the wrong method on disconnect");
-                        break;
-                }
-                break;
-            }
-            case Protocol::Packet::ChallengeRequest:
-                break;
-            case Protocol::Packet::UserListRequest:
-                break;
-            case Protocol::Packet::ServerListRequest:
-                break;
-            case Protocol::Packet::RoomListRequest:
-                break;
-            case Protocol::Packet::SigmodListRequest:
-                break;
-            case Protocol::Packet::SigmodRequest:
-                break;
-            default:
-                Protocol::PacketMaker::unhandledRequest(client, QStringList() << QString("server-").arg(m_name));
-                break;
-        }
-    }
-    else
-    {
-        createRoom(receiver);
-        m_rooms[receiver]->packetReceived(client, packet);
-    }
+    return QStringList() << QString("server-%1").arg(m_name);
+}
+
+void Signet::Server::start()
+{
+    QTcpServer* server = new QTcpServer(this);
+    server->listen(QHostAddress::Any, m_port);
 }
 
 void Signet::Server::createRoom(const QString& room)
 {
+    QMutexLocker locker(&m_mutex);
     if (m_rooms.contains(room))
         return;
     m_rooms[room] = new Room(room, this);
@@ -127,6 +65,7 @@ void Signet::Server::createRoom(const QString& room)
 
 void Signet::Server::closeRoom(const QString& room)
 {
+    QMutexLocker locker(&m_mutex);
     if (m_rooms.contains(room))
     {
         delete m_rooms[room];
@@ -146,6 +85,7 @@ void Signet::Server::metaserverConnected()
     {
         case Protocol::ChallengeMediator::NoError:
             qDebug("Authenticated with metaserver");
+            // TODO: Send server information
             break;
         case Protocol::ChallengeMediator::UnknownUser:
             qWarning("Server is not registered with the metaserver");
@@ -165,6 +105,9 @@ void Signet::Server::metaserverConnected()
         case Protocol::ChallengeMediator::SideError:
             qCritical("Acted on wrong end of authentication");
             break;
+        case Protocol::ChallengeMediator::ReceiverError:
+            qCritical("Wrong destination for packet");
+            break;
     }
 }
 
@@ -179,11 +122,21 @@ void Signet::Server::metaserverError()
     qWarning("Metaserver socket error: %s", m_metaserver->errorString().toUtf8().constData());
 }
 
+void Signet::Server::newConnection()
+{
+    QTcpSocket* socket = m_server->nextPendingConnection();
+    ServerConnectionHandler* handler = new ServerConnectionHandler(socket, this);
+    connect(handler, SIGNAL(finished()), socket, SLOT(deleteLater()));
+    handler->run();
+}
+
 void Signet::Server::loadConfiguration()
 {
     if (KGlobal::config()->hasGroup("Metaserver"))
         m_metaserverInfo.load(KGlobal::config()->group("Metaserver"));
-    m_name = KGlobal::config()->group("Server Info").readEntry("Name", "");
+    KConfigGroup config = KGlobal::config()->group("Server Info");
+    m_name = config.readEntry("Name", "");
+    m_port = config.readEntry("Port", 49959);
 }
 
 void Signet::Server::connectToMetaserver()
diff --git a/signet/Server.h b/signet/Server.h
index 0a52e4b3..41aa81e7 100644
--- a/signet/Server.h
+++ b/signet/Server.h
@@ -25,17 +25,20 @@
 
 // Qt includes
 #include <QtCore/QMap>
+#include <QtCore/QMutex>
 #include <QtCore/QObject>
 #include <QtCore/QUuid>
 #include <QtNetwork/QHostAddress>
 
 // Forward declarations
 class KConfigGroup;
+class QTcpServer;
 class QTcpSocket;
 
 namespace Signet
 {
 class Room;
+class ServerConnectionHandler;
 
 class SIGNET_EXPORT Server : public ClientHandler
 {
@@ -43,8 +46,10 @@ class SIGNET_EXPORT Server : public ClientHandler
     
     public:
         Server(QObject* parent);
-    public slots:
-        void packetReceived(QTcpSocket* client, Protocol::Packet* packet);
+        
+        QStringList receiveChain() const;
+        
+        void start();
     signals:
         void globalMessage(const QString& message);
     protected:
@@ -56,14 +61,22 @@ class SIGNET_EXPORT Server : public ClientHandler
         void metaserverDisconnected();
         void metaserverError();
         
+        void newConnection();
+        
         void loadConfiguration();
         
         void connectToMetaserver();
     private:
+        friend class ServerConnectionHandler;
+        
         QTcpSocket* m_metaserver;
+        QTcpServer* m_server;
+        
+        QMutex m_mutex;
         
         ConnectionInfo m_metaserverInfo;
         QString m_name;
+        quint16 m_port;
         
         QMap<QString, Room*> m_rooms;
 };
diff --git a/signet/ServerConnectionHandler.cpp b/signet/ServerConnectionHandler.cpp
new file mode 100644
index 00000000..940b3421
--- /dev/null
+++ b/signet/ServerConnectionHandler.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2008 Ben Boeckel <MathStuf@gmail.com>
+ * 
+ * This program 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, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+// Header include
+#include "ServerConnectionHandler.h"
+
+// Protocol includes
+#include "protocol/ChallengeMediator.h"
+#include "protocol/ConnectMediator.h"
+#include "protocol/DisconnectMediator.h"
+#include "protocol/Packet.h"
+#include "protocol/PacketMaker.h"
+
+// Signet includes
+#include "Room.h"
+#include "Server.h"
+
+// Qt includes
+#include <QtNetwork/QTcpSocket>
+
+Signet::ServerConnectionHandler::ServerConnectionHandler(QTcpSocket* socket, Server* server) :
+        QThread(server),
+        m_socket(socket),
+        m_server(server)
+{
+}
+
+void Signet::ServerConnectionHandler::run()
+{
+    Protocol::Packet packet = Protocol::PacketMaker::unwrap(m_socket);
+    const QString receiver = packet.received();
+    if (receiver.startsWith("server-") && receiver.endsWith(m_server->m_name))
+    {
+        switch (packet.type())
+        {
+            case Protocol::Packet::ConnectRequest:
+            {
+                Protocol::ConnectMediator mediator(m_socket, Protocol::ConnectMediator::Server, m_server->receiveChain());
+                Protocol::ConnectMediator::Error error = mediator.replyToConnection();
+                switch (error)
+                {
+                    case Protocol::ConnectMediator::NoError:
+                        qDebug("Client connected from %s:%d", m_socket->peerAddress().toString().toUtf8().constData(), m_socket->peerPort());
+                        break;
+                    case Protocol::ConnectMediator::SocketError:
+                        qWarning("Socket error on connect");
+                        break;
+                    case Protocol::ConnectMediator::UnexpectedError:
+                        qWarning("Unexpected packet from %s:%d on connect", m_socket->peerAddress().toString().toUtf8().constData(), m_socket->peerPort());
+                        break;
+                    case Protocol::ConnectMediator::SideError:
+                        qCritical("Called the wrong method on connect");
+                        break;
+                    case Protocol::ConnectMediator::ReceiverError:
+                        qCritical("Wrong destination for packet");
+                        break;
+                }
+                break;
+            }
+            case Protocol::Packet::DisconnectRequest:
+            {
+                Protocol::DisconnectMediator mediator(m_socket, Protocol::DisconnectMediator::Server, m_server->receiveChain());
+                Protocol::DisconnectMediator::Error error = mediator.replyToDisconnection();
+                switch (error)
+                {
+                    case Protocol::DisconnectMediator::NoError:
+                        qDebug("Client disconnected from %s:%d", m_socket->peerAddress().toString().toUtf8().constData(), m_socket->peerPort());
+                        break;
+                    case Protocol::DisconnectMediator::SocketError:
+                        qWarning("Socket error on disconnect");
+                        break;
+                    case Protocol::DisconnectMediator::UnexpectedError:
+                        qWarning("Unexpected packet from %s:%d on disconnect", m_socket->peerAddress().toString().toUtf8().constData(), m_socket->peerPort());
+                        break;
+                    case Protocol::DisconnectMediator::SideError:
+                        qCritical("Called the wrong method on disconnect");
+                        break;
+                    case Protocol::DisconnectMediator::ReceiverError:
+                        qCritical("Wrong destination for packet");
+                        break;
+                }
+                break;
+            }
+            case Protocol::Packet::ChallengeRequest:
+                // TODO
+                break;
+            case Protocol::Packet::UserListRequest:
+                // TODO
+                break;
+            case Protocol::Packet::ServerListRequest:
+                // TODO
+                break;
+            case Protocol::Packet::RoomListRequest:
+                // TODO
+                break;
+            case Protocol::Packet::SigmodListRequest:
+                // TODO
+                break;
+            case Protocol::Packet::SigmodRequest:
+                // TODO
+                break;
+            default:
+                Protocol::PacketMaker::unhandledRequest(m_socket, m_server->receiveChain());
+                break;
+        }
+    }
+    else
+    {
+        if (receiver.startsWith("room-"))
+        {
+            const QString room = receiver.mid(receiver.indexOf('-') + 1);
+            m_server->createRoom(room);
+            if (m_server->m_rooms.contains(room))
+                m_server->m_rooms[room]->packetReceived(m_socket, &packet);
+            else
+                qCritical("Failed to create room %s", room.toUtf8().constData());
+        }
+    }
+}
diff --git a/signet/ServerConnectionHandler.h b/signet/ServerConnectionHandler.h
new file mode 100644
index 00000000..830da1cd
--- /dev/null
+++ b/signet/ServerConnectionHandler.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2008 Ben Boeckel <MathStuf@gmail.com>
+ * 
+ * This program 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, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SIGNET_SERVERCONNECTIONHANDLER
+#define SIGNET_SERVERCONNECTIONHANDLER
+
+// Signet includes
+#include "Global.h"
+
+// Qt includes
+#include <QtCore/QThread>
+
+// Forward declarations
+class QTcpSocket;
+
+namespace Signet
+{
+class Server;
+
+class SIGNET_EXPORT ServerConnectionHandler : public QThread
+{
+    Q_OBJECT
+    
+    public:
+        ServerConnectionHandler(QTcpSocket* socket, Server* server);
+        
+        void run();
+    private:
+        QTcpSocket* m_socket;
+        Server* m_server;
+};
+}
+
+#endif
diff --git a/signet/Table.cpp b/signet/Table.cpp
index 89012237..85099337 100644
--- a/signet/Table.cpp
+++ b/signet/Table.cpp
@@ -21,15 +21,24 @@
 // Protocol includes
 #include "protocol/PacketMaker.h"
 
+// Signet includes
+#include "Room.h"
+
 // Qt includes
 #include <QtNetwork/QTcpSocket>
 
-Signet::Table::Table(const QString& name, QObject* parent) :
-        ClientHandler(parent),
+Signet::Table::Table(const QString& name, Room* room) :
+        ClientHandler(room),
+        m_room(room),
         m_name(name)
 {
 }
 
+QStringList Signet::Table::receiveChain() const
+{
+    return m_room->receiveChain() << QString("table-").arg(m_name);
+}
+
 void Signet::Table::packetReceived(QTcpSocket* client, Protocol::Packet* packet)
 {
     QString receiver = packet->received();
diff --git a/signet/Table.h b/signet/Table.h
index 4c9aeb33..304c9807 100644
--- a/signet/Table.h
+++ b/signet/Table.h
@@ -26,16 +26,20 @@ namespace Signet
 {
 // Forward declarations
 class Client;
+class Room;
 
 class SIGNET_EXPORT Table : public ClientHandler
 {
     Q_OBJECT
     
     public:
-        Table(const QString& name, QObject* parent);
+        Table(const QString& name, Room* room);
+        
+        QStringList receiveChain() const;
     public slots:
         void packetReceived(QTcpSocket* client, Protocol::Packet* packet);
     private:
+        Room* m_room;
         QString m_name;        
 };
 }
diff --git a/signet/protocol/ChallengeMediator.cpp b/signet/protocol/ChallengeMediator.cpp
index 45d70deb..e28dbbeb 100644
--- a/signet/protocol/ChallengeMediator.cpp
+++ b/signet/protocol/ChallengeMediator.cpp
@@ -29,8 +29,9 @@
 #include <QtCore/QUuid>
 #include <QtNetwork/QTcpSocket>
 
-Signet::Protocol::ChallengeMediator::ChallengeMediator(QTcpSocket* socket, Side side) :
+Signet::Protocol::ChallengeMediator::ChallengeMediator(QTcpSocket* socket, Side side, const QStringList& receivers) :
         m_side(side),
+        m_receivers(receivers),
         m_error(NoError),
         m_socket(socket)
 {
@@ -47,15 +48,21 @@ Signet::Protocol::ChallengeMediator::Error Signet::Protocol::ChallengeMediator::
     QByteArray expectedServerResponse;
     init(id);
     recvServerKey(&serverKey);
-    if (m_error)
+    if (m_error != NoError)
+    {
+        notifyServerFail();
         return m_error;
+    }
     clientKey = generateChallengeKey();
     clientResponse = generateResponse(clientKey, serverKey, secret);
     expectedServerResponse = generateResponse(serverKey, clientKey, secret);
     sendClientResponse(clientKey, clientResponse);
     recvServerResponse(&serverResponse);
-    if (m_error)
+    if (m_error != NoError)
+    {
+        notifyServerFail();
         return m_error;
+    }
     if (serverResponse == expectedServerResponse)
         notifyServerPass();
     else
@@ -77,12 +84,15 @@ Signet::Protocol::ChallengeMediator::Error Signet::Protocol::ChallengeMediator::
     serverKey = generateChallengeKey();
     sendServerKey(serverKey);
     recvClientResponse(&clientKey, &clientResponse);
-    if (m_error)
+    if (m_error != NoError)
+    {
+        notifyClientFail();
         return m_error;
+    }
     expectedClientResponse = generateResponse(clientKey, serverKey, secret);
     if (clientResponse != expectedClientResponse)
         notifyClientFail();
-    if (m_error)
+    if (m_error != NoError)
         return m_error;
     serverResponse = generateResponse(serverKey, clientKey, secret);
     sendServerResponse(serverResponse);
@@ -111,12 +121,12 @@ QByteArray Signet::Protocol::ChallengeMediator::generateResponse(const QByteArra
 
 void Signet::Protocol::ChallengeMediator::init(const QByteArray& id)
 {
-    PacketMaker::challenge(m_socket, id);
+    PacketMaker::challenge(m_socket, id, m_receivers);
 }
 
 void Signet::Protocol::ChallengeMediator::sendServerKey(const QByteArray& serverKey)
 {
-    PacketMaker::challengeKey(m_socket, serverKey);
+    PacketMaker::challengeKey(m_socket, serverKey, m_receivers);
 }
 
 void Signet::Protocol::ChallengeMediator::recvServerKey(QByteArray* serverKey)
@@ -125,12 +135,17 @@ void Signet::Protocol::ChallengeMediator::recvServerKey(QByteArray* serverKey)
     Packet packet = PacketMaker::unwrap(m_socket);
     if (packet.isValid())
     {
-        if (packet.type() == Packet::ChallengeKey)
-            packet.rawDump(&buffer);
-        else if (packet.type() == Packet::Denial)
-            m_error = UnknownUser;
+        if (packet.receivers() == m_receivers)
+        {
+            if (packet.type() == Packet::ChallengeKey)
+                packet.rawDump(&buffer);
+            else if (packet.type() == Packet::Denial)
+                m_error = UnknownUser;
+            else
+                m_error = UnexpectedError;
+        }
         else
-            m_error = UnexpectedError;
+            m_error = ReceiverError;
     }
     else
         m_error = SocketError;
@@ -138,8 +153,8 @@ void Signet::Protocol::ChallengeMediator::recvServerKey(QByteArray* serverKey)
 
 void Signet::Protocol::ChallengeMediator::sendClientResponse(const QByteArray& clientKey, const QByteArray& clientResponse)
 {
-    PacketMaker::challengeKey(m_socket, clientKey);
-    PacketMaker::challengeResponse(m_socket, clientResponse);
+    PacketMaker::challengeKey(m_socket, clientKey, m_receivers);
+    PacketMaker::challengeResponse(m_socket, clientResponse, m_receivers);
 }
 
 void Signet::Protocol::ChallengeMediator::recvClientResponse(QByteArray* clientKey, QByteArray* clientResponse)
@@ -148,23 +163,28 @@ void Signet::Protocol::ChallengeMediator::recvClientResponse(QByteArray* clientK
     Packet packet = PacketMaker::unwrap(m_socket);
     if (packet.isValid())
     {
-        if (packet.type() == Packet::ChallengeKey)
+        if (packet.receivers() == m_receivers)
         {
-            packet.rawDump(&buffer);
-            buffer.setBuffer(clientResponse);
-            packet = PacketMaker::unwrap(m_socket);
-            if (packet.isValid())
+            if (packet.type() == Packet::ChallengeKey)
             {
-                if (packet.type() == Packet::ChallengeResponse)
-                    packet.rawDump(&buffer);
+                packet.rawDump(&buffer);
+                buffer.setBuffer(clientResponse);
+                packet = PacketMaker::unwrap(m_socket);
+                if (packet.isValid())
+                {
+                    if (packet.type() == Packet::ChallengeResponse)
+                        packet.rawDump(&buffer);
+                    else
+                        m_error = UnexpectedError;
+                }
                 else
-                    m_error = UnexpectedError;
+                    m_error = SocketError;
             }
             else
-                m_error = SocketError;
+                m_error = UnexpectedError;
         }
         else
-            m_error = UnexpectedError;
+            m_error = ReceiverError;
     }
     else
         m_error = SocketError;
@@ -172,7 +192,7 @@ void Signet::Protocol::ChallengeMediator::recvClientResponse(QByteArray* clientK
 
 void Signet::Protocol::ChallengeMediator::sendServerResponse(const QByteArray& serverResponse)
 {
-    PacketMaker::challengeResponse(m_socket, serverResponse);
+    PacketMaker::challengeResponse(m_socket, serverResponse, m_receivers);
 }
 
 void Signet::Protocol::ChallengeMediator::recvServerResponse(QByteArray* serverResponse)
@@ -181,12 +201,17 @@ void Signet::Protocol::ChallengeMediator::recvServerResponse(QByteArray* serverR
     Packet packet = PacketMaker::unwrap(m_socket);
     if (packet.isValid())
     {
-        if (packet.type() == Packet::ChallengeResponse)
-            packet.rawDump(&buffer);
-        else if (packet.type() == Packet::Denial)
-            m_error = ClientFailed;
+        if (packet.receivers() == m_receivers)
+        {
+            if (packet.type() == Packet::ChallengeResponse)
+                packet.rawDump(&buffer);
+            else if (packet.type() == Packet::Denial)
+                m_error = ClientFailed;
+            else
+                m_error = UnexpectedError;
+        }
         else
-            m_error = UnexpectedError;
+            m_error = ReceiverError;
     }
     else
         m_error = SocketError;
@@ -197,10 +222,15 @@ void Signet::Protocol::ChallengeMediator::recvClientAnswer()
     Packet packet = PacketMaker::unwrap(m_socket);
     if (packet.isValid())
     {
-        if (packet.type() == Packet::Denial)
-            m_error = ServerFailed;
-        else if (packet.type() != Packet::Acceptance)
-            m_error = UnexpectedError;
+        if (packet.receivers() == m_receivers)
+        {
+            if (packet.type() == Packet::Denial)
+                m_error = ServerFailed;
+            else if (packet.type() != Packet::Acceptance)
+                m_error = UnexpectedError;
+        }
+        else
+            m_error = ReceiverError;
     }
     else
         m_error = SocketError;
@@ -208,23 +238,23 @@ void Signet::Protocol::ChallengeMediator::recvClientAnswer()
 
 void Signet::Protocol::ChallengeMediator::notifyServerFail()
 {
-    PacketMaker::deny(m_socket);
+    PacketMaker::deny(m_socket, m_receivers);
     m_error = ServerFailed;
 }
 
 void Signet::Protocol::ChallengeMediator::notifyServerPass()
 {
-    PacketMaker::accept(m_socket);
+    PacketMaker::accept(m_socket, m_receivers);
 }
 
 void Signet::Protocol::ChallengeMediator::notifyClientFail()
 {
-    PacketMaker::deny(m_socket);
+    PacketMaker::deny(m_socket, m_receivers);
     m_error = ClientFailed;
 }
 
 void Signet::Protocol::ChallengeMediator::notifyClientUnknown()
 {
-    PacketMaker::deny(m_socket);
+    PacketMaker::deny(m_socket, m_receivers);
     m_error = UnknownUser;
 }
diff --git a/signet/protocol/ChallengeMediator.h b/signet/protocol/ChallengeMediator.h
index e34ef72e..dfc14e5e 100644
--- a/signet/protocol/ChallengeMediator.h
+++ b/signet/protocol/ChallengeMediator.h
@@ -21,6 +21,9 @@
 // Signet includes
 #include "../Global.h"
 
+// Qt includes
+#include <QtCore/QStringList>
+
 // Forward declarations
 class QTcpSocket;
 
@@ -33,13 +36,14 @@ class SIGNET_IMPORT ChallengeMediator
     public:
         enum Error
         {
-            NoError         = 0x00,
-            UnknownUser     = 0x01,
-            ClientFailed    = 0x02,
-            ServerFailed    = 0x04,
-            SocketError     = 0x08,
-            UnexpectedError = 0x10,
-            SideError       = 0x20
+            NoError         = 0,
+            UnknownUser     = 1,
+            ClientFailed    = 2,
+            ServerFailed    = 3,
+            SocketError     = 4,
+            UnexpectedError = 5,
+            SideError       = 6,
+            ReceiverError   = 7
         };
         
         enum Side
@@ -48,7 +52,7 @@ class SIGNET_IMPORT ChallengeMediator
             Server = 1
         };
         
-        ChallengeMediator(QTcpSocket* socket, Side side);
+        ChallengeMediator(QTcpSocket* socket, Side side, const QStringList& receivers = QStringList());
         
         Error challenge(const QByteArray& id, const QByteArray& secret);
         Error challenged(const QByteArray& secret);
@@ -75,6 +79,7 @@ class SIGNET_IMPORT ChallengeMediator
         void notifyClientUnknown();
     private:
         const Side m_side;
+        const QStringList& m_receivers;
         Error m_error;
         QTcpSocket* m_socket;
 };
diff --git a/signet/protocol/ConnectMediator.cpp b/signet/protocol/ConnectMediator.cpp
index 5610281a..5fb09789 100644
--- a/signet/protocol/ConnectMediator.cpp
+++ b/signet/protocol/ConnectMediator.cpp
@@ -24,8 +24,9 @@
 // Qt includes
 #include <QtNetwork/QTcpSocket>
 
-Signet::Protocol::ConnectMediator::ConnectMediator(QTcpSocket* socket, Side side) :
+Signet::Protocol::ConnectMediator::ConnectMediator(QTcpSocket* socket, Side side, const QStringList& receivers) :
         m_side(side),
+        m_receivers(receivers),
         m_error(NoError),
         m_socket(socket)
 {
@@ -46,19 +47,22 @@ Signet::Protocol::ConnectMediator::Error Signet::Protocol::ConnectMediator::repl
         return SideError;
     recvAck();
     if (m_error != NoError)
+    {
+        failure();
         return m_error;
+    }
     sendAck();
     return m_error;
 }
 
 void Signet::Protocol::ConnectMediator::init()
 {
-    PacketMaker::makeConnection(m_socket);
+    PacketMaker::makeConnection(m_socket, m_receivers);
 }
 
 void Signet::Protocol::ConnectMediator::sendAck()
 {
-    PacketMaker::ack(m_socket);
+    PacketMaker::ack(m_socket, m_receivers);
 }
 
 void Signet::Protocol::ConnectMediator::recvAck()
@@ -66,9 +70,19 @@ void Signet::Protocol::ConnectMediator::recvAck()
     Packet packet = PacketMaker::unwrap(m_socket);
     if (packet.isValid())
     {
-        if (packet.type() != Packet::Acknowledge)
-            m_error = UnexpectedError;
+        if (packet.receivers() == m_receivers)
+        {
+            if (packet.type() != Packet::Acknowledge)
+                m_error = UnexpectedError;
+        }
+        else
+            m_error = ReceiverError;
     }
     else
         m_error = SocketError;
 }
+
+void Signet::Protocol::ConnectMediator::failure()
+{
+    PacketMaker::deny(m_socket, m_receivers);
+}
diff --git a/signet/protocol/ConnectMediator.h b/signet/protocol/ConnectMediator.h
index 666d7409..1e18e772 100644
--- a/signet/protocol/ConnectMediator.h
+++ b/signet/protocol/ConnectMediator.h
@@ -21,6 +21,9 @@
 // Signet includes
 #include "../Global.h"
 
+// Qt includes
+#include <QtCore/QStringList>
+
 // Forward declarations
 class QTcpSocket;
 
@@ -36,7 +39,8 @@ class SIGNET_IMPORT ConnectMediator
             NoError         = 0,
             SocketError     = 1,
             UnexpectedError = 2,
-            SideError       = 3
+            SideError       = 3,
+            ReceiverError   = 4
         };
         
         enum Side
@@ -45,7 +49,7 @@ class SIGNET_IMPORT ConnectMediator
             Server  = 1
         };
         
-        ConnectMediator(QTcpSocket* socket, Side side);
+        ConnectMediator(QTcpSocket* socket, Side side, const QStringList& receivers = QStringList());
         
         Error requestConnection();
         Error replyToConnection();
@@ -54,8 +58,11 @@ class SIGNET_IMPORT ConnectMediator
         
         void sendAck();
         void recvAck();
+        
+        void failure();
     private:
         const Side m_side;
+        const QStringList& m_receivers;
         Error m_error;
         QTcpSocket* m_socket;
 };
diff --git a/signet/protocol/DisconnectMediator.cpp b/signet/protocol/DisconnectMediator.cpp
index 8f67731d..effbc4e0 100644
--- a/signet/protocol/DisconnectMediator.cpp
+++ b/signet/protocol/DisconnectMediator.cpp
@@ -24,8 +24,9 @@
 // Qt includes
 #include <QtNetwork/QTcpSocket>
 
-Signet::Protocol::DisconnectMediator::DisconnectMediator(QTcpSocket* socket, Side side) :
+Signet::Protocol::DisconnectMediator::DisconnectMediator(QTcpSocket* socket, Side side, const QStringList& receivers) :
         m_side(side),
+        m_receivers(receivers),
         m_error(NoError),
         m_socket(socket)
 {
@@ -46,19 +47,22 @@ Signet::Protocol::DisconnectMediator::Error Signet::Protocol::DisconnectMediator
         return SideError;
     recvAck();
     if (m_error != NoError)
+    {
+        failure();
         return m_error;
+    }
     sendAck();
     return m_error;
 }
 
 void Signet::Protocol::DisconnectMediator::init()
 {
-    PacketMaker::dropConnection(m_socket);
+    PacketMaker::dropConnection(m_socket, m_receivers);
 }
 
 void Signet::Protocol::DisconnectMediator::sendAck()
 {
-    PacketMaker::ack(m_socket);
+    PacketMaker::ack(m_socket, m_receivers);
 }
 
 void Signet::Protocol::DisconnectMediator::recvAck()
@@ -66,9 +70,19 @@ void Signet::Protocol::DisconnectMediator::recvAck()
     Packet packet = PacketMaker::unwrap(m_socket);
     if (packet.isValid())
     {
-        if (packet.type() != Packet::Acknowledge)
-            m_error = UnexpectedError;
+        if (packet.receivers() == m_receivers)
+        {
+            if (packet.type() != Packet::Acknowledge)
+                m_error = UnexpectedError;
+        }
+        else
+            m_error = ReceiverError;
     }
     else
         m_error = SocketError;
 }
+
+void Signet::Protocol::DisconnectMediator::failure()
+{
+    PacketMaker::deny(m_socket, m_receivers);
+}
diff --git a/signet/protocol/DisconnectMediator.h b/signet/protocol/DisconnectMediator.h
index cb8a9694..6bac3298 100644
--- a/signet/protocol/DisconnectMediator.h
+++ b/signet/protocol/DisconnectMediator.h
@@ -21,6 +21,9 @@
 // Signet includes
 #include "../Global.h"
 
+// Qt includes
+#include <QtCore/QStringList>
+
 // Forward declarations
 class QTcpSocket;
 
@@ -36,7 +39,8 @@ class SIGNET_IMPORT DisconnectMediator
             NoError         = 0,
             SocketError     = 1,
             UnexpectedError = 2,
-            SideError       = 3
+            SideError       = 3,
+            ReceiverError   = 4
         };
         
         enum Side
@@ -45,7 +49,7 @@ class SIGNET_IMPORT DisconnectMediator
             Server  = 1
         };
         
-        DisconnectMediator(QTcpSocket* socket, Side side);
+        DisconnectMediator(QTcpSocket* socket, Side side, const QStringList& receivers = QStringList());
         
         Error requestDisconnection();
         Error replyToDisconnection();
@@ -54,8 +58,11 @@ class SIGNET_IMPORT DisconnectMediator
         
         void sendAck();
         void recvAck();
+        
+        void failure();
     private:
         const Side m_side;
+        const QStringList& m_receivers;
         Error m_error;
         QTcpSocket* m_socket;
 };
diff --git a/signet/signet.pro b/signet/signet.pro
index b8363467..7679455d 100644
--- a/signet/signet.pro
+++ b/signet/signet.pro
@@ -21,16 +21,31 @@ include(../install.pri)
 include(../kde4.pri)
 
 SOURCES += Client.cpp \
- ConnectionHandler.cpp \
+ ClientHandler.cpp \
+ ConnectionInfo.cpp \
  Room.cpp \
  Server.cpp \
- Table.cpp
+ ServerConnectionHandler.cpp \
+ Table.cpp \
+ protocol/ChallengeMediator.cpp \
+ protocol/ConnectMediator.cpp \
+ protocol/DisconnectMediator.cpp \
+ protocol/Packet.cpp \
+ protocol/PacketMaker.cpp \
 
 HEADERS += Client.h \
- ConnectionHandler.h \
+ ClientHandler.h \
+ ConnectionInfo.h \
  Global.h \
  Room.h \
  Server.h \
- Table.h
+ ServerConnectionHandler.h \
+ Table.h \
+ protocol/ChallengeMediator.h \
+ protocol/ConnectMediator.h \
+ protocol/DisconnectMediator.h \
+ protocol/Packet.h \
+ protocol/PacketMaker.h \
+ protocol/ProgressMeter.h
 
 include(../headers.pri)