[FIX] Defined the *_IMPORT defines for libraries

[FIX] Added more packet types
[FIX] Sectioned off packet types
[FIX] ConnectionHandler is now ClientHandler
[ADD] Added a ProgressMeter class for allowing display of progress of packets

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

18 files changed, 268 insertions, 147 deletions

diff --git a/signet/CMakeLists.txt b/signet/CMakeLists.txt
index f596b2af..190c5520 100644
--- a/signet/CMakeLists.txt
+++ b/signet/CMakeLists.txt
@@ -6,13 +6,15 @@ ENDIF (NOT SIGEN_VERSION)
 
 SET(signet_PROTOCOL_HEADERS
     protocol/ChallengeMediator.h
+    protocol/ConnectMediator.h
     protocol/Packet.h
     protocol/PacketMaker.h
+    protocol/ProgressMeter.h
 )
 SET(signet_HEADERS
     ${signet_PROTOCOL_HEADERS}
     Client.h
-    ConnectionHandler.h
+    ClientHandler.h
     ConnectionInfo.h
     Global.h
     Room.h
@@ -27,7 +29,7 @@ SET(signet_PROTOCOL_SRCS
 SET(signet_SRCS
     ${signet_PROTOCOL_SRCS}
     Client.cpp
-    ConnectionHandler.cpp
+    ClientHandler.cpp
     ConnectionInfo.cpp
     Room.cpp
     Server.cpp
diff --git a/signet/ConnectionHandler.cpp b/signet/ClientHandler.cpp
index 71fc10ec..d5638b12 100644
--- a/signet/ConnectionHandler.cpp
+++ b/signet/ClientHandler.cpp
@@ -16,36 +16,28 @@
  */
 
 // Header include
-#include "ConnectionHandler.h"
-
-// Protocol includes
-#include "protocol/ChallengeMediator.h"
+#include "ClientHandler.h"
 
 // Signet includes
 #include "Client.h"
 
-Signet::ConnectionHandler::ConnectionHandler(QObject* parent) :
+Signet::ClientHandler::ClientHandler(QObject* parent) :
         QObject(parent)
 {
 }
 
-QByteArray Signet::ConnectionHandler::secretForHost(const QByteArray& id) const
-{
-    Q_UNUSED(id)
-    return QByteArray();
-}
-
-bool Signet::ConnectionHandler::addClient(Client* socket)
+bool Signet::ClientHandler::addClient(QTcpSocket* client)
 {
-    // TODO: Add the client
+    m_clients.append(client);
 }
 
-bool Signet::ConnectionHandler::removeClient(Client* socket)
+bool Signet::ClientHandler::removeClient(QTcpSocket* client)
 {
-    // TODO: Remove the client
+    m_clients.removeAll(client);
 }
 
-void Signet::ConnectionHandler::sendData(Client* client, const QByteArray& data)
+QByteArray Signet::ClientHandler::secretForClient(const QByteArray& id) const
 {
-    // TODO: Send data to the client
+    Q_UNUSED(id)
+    return QByteArray();
 }
diff --git a/signet/ConnectionHandler.h b/signet/ClientHandler.h
index 0e62934a..a7292619 100644
--- a/signet/ConnectionHandler.h
+++ b/signet/ClientHandler.h
@@ -15,47 +15,39 @@
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SIGNET_CONNECTIONHANDLER
-#define SIGNET_CONNECTIONHANDLER
+#ifndef SIGNET_CLIENTHANDLER
+#define SIGNET_CLIENTHANDLER
 
 // Protocol includes
-#include "protocol/ChallengeMediator.h"
+#include "protocol/Packet.h"
 
 // Signet includes
 #include "Global.h"
 
 // Qt includes
-#include <QtCore/QMap>
+#include <QtCore/QList>
 #include <QtCore/QObject>
 
 // Forward declarations
-class QHostAddress;
 class QTcpSocket;
 
 namespace Signet
 {
-class Client;
-
-class SIGNET_EXPORT ConnectionHandler : public QObject
+class SIGNET_EXPORT ClientHandler : public QObject
 {
     Q_OBJECT
     
     public:
-        ConnectionHandler(QObject* parent);
-        
-        virtual QString type() const = 0;
-        virtual QString name() const = 0;
+        ClientHandler(QObject* parent);
     public slots:
-        bool addClient(Client* socket);
-        bool removeClient(Client* socket);
-    signals:
-        void dataReceived(const QByteArray& data);
+        bool addClient(QTcpSocket* client);
+        bool removeClient(QTcpSocket* client);
+        
+        virtual void packetReceived(QTcpSocket* client, Protocol::Packet* packet) = 0;
     protected:
-        virtual QByteArray secretForHost(const QByteArray& id) const;
-    protected slots:
-        void sendData(Client* client, const QByteArray& data);
+        virtual QByteArray secretForClient(const QByteArray& id) const;
     private:
-        QList<Client*> m_clients;
+        QList<QTcpSocket*> m_clients;
 };
 }
 
diff --git a/signet/Global.h b/signet/Global.h
index dc68ead7..f24a3562 100644
--- a/signet/Global.h
+++ b/signet/Global.h
@@ -27,6 +27,7 @@
 #   else
 #       define SIGNET_EXPORT KDE_IMPORT
 #   endif
+#   define SIGNET_IMPORT KDE_IMPORT
 #endif
 
 #ifndef SIGNET_EXPORT_DEPRECATED
diff --git a/signet/Room.cpp b/signet/Room.cpp
index fad6c332..6fbc3dcb 100644
--- a/signet/Room.cpp
+++ b/signet/Room.cpp
@@ -19,22 +19,28 @@
 #include "Room.h"
 
 // Signet includes
+#include "Server.h"
 #include "Table.h"
 
-Signet::Room::Room(const QString& name, QObject* parent) :
-        ConnectionHandler(parent),
+Signet::Room::Room(const QString& name, Server* server) :
+        ClientHandler(server),
+        m_server(server),
         m_name(name)
 {
 }
 
-QString Signet::Room::type() const
+void Signet::Room::packetReceived(QTcpSocket* client, Protocol::Packet* packet)
 {
-    return "room";
-}
-
-QString Signet::Room::name() const
-{
-    return m_name;
+    QString receiver = packet->received();
+    if (receiver.isEmpty())
+    {
+        // TODO: Handle the packet
+    }
+    else
+    {
+        createTable(receiver);
+        m_tables[receiver]->packetReceived(client, packet);
+    }
 }
 
 void Signet::Room::createTable(const QString& table)
@@ -52,15 +58,3 @@ void Signet::Room::closeTable(const QString& table)
         m_tables.remove(table);
     }
 }
-
-bool Signet::Room::joinTable(Client* client, const QString& tableName)
-{
-    if (!m_tables.contains(tableName))
-        createTable(tableName);
-    if (!m_tables[tableName]->addClient(client))
-    {
-        // TODO: Let the client know about the error.
-        return false;
-    }
-    return true;
-}
diff --git a/signet/Room.h b/signet/Room.h
index 8cc0ca8a..2b3c7b74 100644
--- a/signet/Room.h
+++ b/signet/Room.h
@@ -19,7 +19,7 @@
 #define SIGNET_ROOM
 
 // Signet includes
-#include "ConnectionHandler.h"
+#include "ClientHandler.h"
 #include "Global.h"
 
 // Qt includes
@@ -28,27 +28,24 @@
 namespace Signet
 {
 // Forward declarations
-class Client;
 class Table;
+class Server;
 
-class SIGNET_EXPORT Room : public ConnectionHandler
+class SIGNET_EXPORT Room : public ClientHandler
 {
     Q_OBJECT
     
     public:
-        Room(const QString& name, QObject* parent);
-        
-        QString type() const;
-        QString name() const;
+        Room(const QString& name, Server* server);
     public slots:
+        void packetReceived(QTcpSocket* client, Protocol::Packet* packet);
     signals:
         void globalMessage(const QString& message);
     protected:
         void createTable(const QString& table);
         void closeTable(const QString& table);
-    protected slots:
-        bool joinTable(Client* client, const QString& tableName);
     private:
+        Server* m_server;
         QString m_name;
         QMap<QString, Table*> m_tables;
 };
diff --git a/signet/Server.cpp b/signet/Server.cpp
index aceba291..df61f47f 100644
--- a/signet/Server.cpp
+++ b/signet/Server.cpp
@@ -35,13 +35,27 @@
 #include <QtNetwork/QTcpSocket>
 
 Signet::Server::Server(QObject* parent) :
-        ConnectionHandler(parent)
+        ClientHandler(parent)
 {
     loadConfiguration();
     if (m_masterInfo.isValid())
         connectToMaster();
 }
 
+void Signet::Server::packetReceived(QTcpSocket* client, Protocol::Packet* packet)
+{
+    QString receiver = packet->received();
+    if (receiver.isEmpty())
+    {
+        // TODO: Handle the packet
+    }
+    else
+    {
+        createRoom(receiver);
+        m_rooms[receiver]->packetReceived(client, packet);
+    }
+}
+
 void Signet::Server::createRoom(const QString& room)
 {
     if (m_rooms.contains(room))
@@ -103,29 +117,11 @@ void Signet::Server::masterError()
     qWarning("Master server socket error: %s", m_master->errorString().toUtf8().constData());
 }
 
-void Signet::Server::joinRoom(Client* client, const QString& roomName)
-{
-    if (!m_rooms.contains(roomName))
-        createRoom(roomName);
-    if (!m_rooms[roomName]->addClient(client))
-    {
-        // TODO: Let the client know about the error.
-    }
-}
-
 void Signet::Server::loadConfiguration()
 {
     if (KGlobal::config()->hasGroup("Master Server"))
         m_masterInfo.load(KGlobal::config()->group("Master Server"));
-    if (KGlobal::config()->hasGroup("Server Info"))
-    {
-        const KConfigGroup& group = KGlobal::config()->group("Server Info");
-        m_name = group.readEntry("Name", "");
-        if (m_name.isEmpty())
-            qFatal("Server name is not set");
-    }
-    else
-        qFatal("No \"Server Info\" group in configuration");
+    m_name = KGlobal::config()->group("Server Info").readEntry("Name", "");
 }
 
 void Signet::Server::connectToMaster()
diff --git a/signet/Server.h b/signet/Server.h
index 4feefb19..0f6314ca 100644
--- a/signet/Server.h
+++ b/signet/Server.h
@@ -19,7 +19,7 @@
 #define SIGNET_SERVER
 
 // Signet includes
-#include "ConnectionHandler.h"
+#include "ClientHandler.h"
 #include "ConnectionInfo.h"
 #include "Global.h"
 
@@ -35,30 +35,27 @@ class QTcpSocket;
 
 namespace Signet
 {
-class Client;
 class Room;
 
-class SIGNET_EXPORT Server : public ConnectionHandler
+class SIGNET_EXPORT Server : public ClientHandler
 {
     Q_OBJECT
     
     public:
         Server(QObject* parent);
+    public slots:
+        void packetReceived(QTcpSocket* client, Protocol::Packet* packet);
     signals:
         void globalMessage(const QString& message);
     protected:
         void createRoom(const QString& room);
         void closeRoom(const QString& room);
-        
-        bool verifyUser(Client* client);
     protected slots:
         void masterFound();
         void masterConnected();
         void masterDisconnected();
         void masterError();
         
-        void joinRoom(Client* client, const QString& roomName);
-        
         void loadConfiguration();
         
         void connectToMaster();
diff --git a/signet/Table.cpp b/signet/Table.cpp
index 1296e825..5cd6373d 100644
--- a/signet/Table.cpp
+++ b/signet/Table.cpp
@@ -18,18 +18,25 @@
 // Header include
 #include "Table.h"
 
+// Protocol includes
+#include "protocol/PacketMaker.h"
+
+// Qt includes
+#include <QtNetwork/QTcpSocket>
+
 Signet::Table::Table(const QString& name, QObject* parent) :
-        ConnectionHandler(parent),
+        ClientHandler(parent),
         m_name(name)
 {
 }
 
-QString Signet::Table::type() const
-{
-    return "table";
-}
-
-QString Signet::Table::name() const
+void Signet::Table::packetReceived(QTcpSocket* client, Protocol::Packet* packet)
 {
-    return m_name;
+    QString receiver = packet->received();
+    if (receiver.isEmpty())
+    {
+        // TODO: Handle the packet
+    }
+    else
+        Protocol::PacketMaker::unknownReceiver(client);
 }
diff --git a/signet/Table.h b/signet/Table.h
index 20a88c54..4c9aeb33 100644
--- a/signet/Table.h
+++ b/signet/Table.h
@@ -19,7 +19,7 @@
 #define SIGNET_TABLE
 
 // Signet includes
-#include "ConnectionHandler.h"
+#include "ClientHandler.h"
 #include "Global.h"
 
 namespace Signet
@@ -27,15 +27,14 @@ namespace Signet
 // Forward declarations
 class Client;
 
-class SIGNET_EXPORT Table : public ConnectionHandler
+class SIGNET_EXPORT Table : public ClientHandler
 {
     Q_OBJECT
     
     public:
         Table(const QString& name, QObject* parent);
-        
-        QString type() const;
-        QString name() const;
+    public slots:
+        void packetReceived(QTcpSocket* client, Protocol::Packet* packet);
     private:
         QString m_name;        
 };
diff --git a/signet/protocol/ChallengeMediator.cpp b/signet/protocol/ChallengeMediator.cpp
index 95f23309..0f09faff 100644
--- a/signet/protocol/ChallengeMediator.cpp
+++ b/signet/protocol/ChallengeMediator.cpp
@@ -103,8 +103,7 @@ QByteArray Signet::Protocol::ChallengeMediator::generateResponse(const QByteArra
         total.append(key1);
         total.append(key2);
         total.append(secret);
-        QCA::Hash sha256("sha256");
-        return sha256.hash(total).toByteArray();
+        return QCA::Hash("sha256").hash(total).toByteArray();
     }
     qFatal("SHA-256 is not supported");
     return QByteArray();
diff --git a/signet/protocol/ChallengeMediator.h b/signet/protocol/ChallengeMediator.h
index 7330ee85..e34ef72e 100644
--- a/signet/protocol/ChallengeMediator.h
+++ b/signet/protocol/ChallengeMediator.h
@@ -28,7 +28,7 @@ namespace Signet
 {
 namespace Protocol
 {
-class SIGNET_EXPORT ChallengeMediator
+class SIGNET_IMPORT ChallengeMediator
 {
     public:
         enum Error
diff --git a/signet/protocol/ConnectMediator.h b/signet/protocol/ConnectMediator.h
new file mode 100644
index 00000000..78c91fc3
--- /dev/null
+++ b/signet/protocol/ConnectMediator.h
@@ -0,0 +1,58 @@
+/*
+ * 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_PROTOCOL_CONNECTMEDIATOR
+#define SIGNET_PROTOCOL_CONNECTMEDIATOR
+
+// Signet includes
+#include "../Global.h"
+
+namespace Signet
+{
+namespace Protocol
+{
+class SIGNET_IMPORT ConnectMediator
+{
+    public:
+        enum Error
+        {
+            NoError         = 0,
+            SocketError     = 1,
+            UnexpectedError = 2,
+            SideError       = 3
+        };
+        
+        enum Side
+        {
+            Client  = 0,
+            Server  = 1
+        };
+        
+        ConnectMediator(QTcpSocket* socket, Side side);
+        
+        Error requestConnection();
+        Error replyToConnection();
+    protected:
+        void init();
+        
+        void sendAck();
+        void recvAck();
+};
+}
+}
+
+#endif
diff --git a/signet/protocol/Packet.cpp b/signet/protocol/Packet.cpp
index 74c785e6..4c346b67 100644
--- a/signet/protocol/Packet.cpp
+++ b/signet/protocol/Packet.cpp
@@ -23,8 +23,9 @@
 #include <QtCore/QBuffer>
 #include <QtCore/QIODevice>
 
-Signet::Protocol::Packet::Packet(const qint16 type) :
-        m_type(type)
+Signet::Protocol::Packet::Packet(const qint16 type, const QStringList& receivers) :
+        m_type(type),
+        m_receivers(receivers)
 {
 }
 
@@ -43,14 +44,11 @@ bool Signet::Protocol::Packet::isValid() const
     return m_type == Invalid;
 }
 
-void Signet::Protocol::Packet::addReceiver(const QString& receiver)
+QString Signet::Protocol::Packet::received()
 {
-    m_receivers << receiver;
-}
-
-void Signet::Protocol::Packet::addReceivers(const QStringList& receivers)
-{
-    m_receivers << receivers;
+    if (m_receivers.isEmpty())
+        return QString();
+    return m_receivers.takeFirst();
 }
 
 void Signet::Protocol::Packet::write(const QByteArray& data)
@@ -83,6 +81,8 @@ void Signet::Protocol::Packet::dump(QIODevice* device) const
     buffer.write(raw, 2);
     foreach (const QString& receiver, m_receivers)
     {
+        if (receiver.isEmpty())
+            continue;
         QByteArray utf8Data = receiver.toUtf8();
         size = receiver.size();
         size = qToBigEndian(size);
diff --git a/signet/protocol/Packet.h b/signet/protocol/Packet.h
index 93034789..a66e94d2 100644
--- a/signet/protocol/Packet.h
+++ b/signet/protocol/Packet.h
@@ -32,17 +32,32 @@ namespace Signet
 {
 namespace Protocol
 {
-class SIGNET_EXPORT Packet
+class SIGNET_IMPORT Packet
 {
     public:
         enum Type
         {
-            Invalid     = -1,
-            RawData     = 0x0000,
-            Acceptance  = 0x0001,
-            Denial      = 0x0002,
-            Challenge   = 0x0003,
-            Message     = 0x0004
+            // Errors
+            UnknownReceiver     = 0x7F00,
+            UnhandledPacket     = 0x7F01,
+            LimitedPermissions  = 0x7F02,
+            Invalid             = 0x7FFF,
+            // Requests
+            ConnectRequest      = 0x0100,
+            DisconnectRequest   = 0x0101,
+            ChallengeRequest    = 0x0102,
+            ServerListRequest   = 0x0103,
+            UserListRequest     = 0x0104,
+            RoomListRequest     = 0x0105,
+            TableListRequest    = 0x0106,
+            SigmodListRequest   = 0x0107,
+            SigmodRequest       = 0x0108,
+            
+            // Data types
+            RawData             = 0x0200,
+            Acceptance          = 0x0201,
+            Denial              = 0x0202,
+            Message             = 0x0204,
         };
         enum SectionType
         {
@@ -50,15 +65,13 @@ class SIGNET_EXPORT Packet
             Payload     = 1
         };
         
-        Packet(const qint16 type = Invalid);
-        // TODO: Add other ctors for other data packages
+        Packet(const qint16 type = Invalid, const QStringList& receivers = QStringList());
         
         qint16 type() const;
         QStringList receivers() const;
         bool isValid() const;
         
-        void addReceiver(const QString& receiver);
-        void addReceivers(const QStringList& receivers);
+        QString received();
         
         void write(const QByteArray& data);
         void rawDump(QIODevice* device) const;
diff --git a/signet/protocol/PacketMaker.cpp b/signet/protocol/PacketMaker.cpp
index 3c398ffe..5ede3996 100644
--- a/signet/protocol/PacketMaker.cpp
+++ b/signet/protocol/PacketMaker.cpp
@@ -18,55 +18,82 @@
 // Header include
 #include "PacketMaker.h"
 
+// Protocol includes
+#include "ProgressMeter.h"
+
 // Qt includes
 #include <QtCore/QtEndian>
 #include <QtCore/QBuffer>
 #include <QtCore/QIODevice>
 
-bool readFromBuffer(char* dest, QIODevice* src, const int size)
+bool readFromBuffer(char* dest, QIODevice* src, const int size, Signet::Protocol::ProgressMeter* progressMeter = 0)
 {
     int totalRead = 0;
+    if (progressMeter)
+        progressMeter->setExpectedSize(size);
     while ((totalRead < size) && src->waitForReadyRead(30000))
     {
         int read = src->read(dest + totalRead, size - totalRead);
         if (read < 0)
+        {
+            if (progressMeter)
+                progressMeter->failure();
             return false;
+        }
         totalRead += read;
+        if (progressMeter)
+            progressMeter->setValue(totalRead);
     }
+    if (progressMeter)
+        progressMeter->success();
     return true;
 }
 
 void Signet::Protocol::PacketMaker::rawData(QIODevice* device, const QByteArray& data, const QStringList& receivers)
 {
-    Packet packet(Packet::RawData);
-    packet.addReceivers(receivers);
+    Packet packet(Packet::RawData, receivers);
     packet.write(data);
     packet.dump(device);
 }
 
 void Signet::Protocol::PacketMaker::deny(QIODevice* device, const QStringList& receivers)
 {
-    Packet packet(Packet::Denial);
-    packet.addReceivers(receivers);
+    Packet packet(Packet::Denial, receivers);
     packet.dump(device);
 }
 
 void Signet::Protocol::PacketMaker::accept(QIODevice* device, const QStringList& receivers)
 {
-    Packet packet(Packet::Acceptance);
-    packet.addReceivers(receivers);
+    Packet packet(Packet::Acceptance, receivers);
     packet.dump(device);
 }
 
 void Signet::Protocol::PacketMaker::challenge(QIODevice* device, const QByteArray& id, const QStringList& receivers)
 {
-    Packet packet(Packet::Challenge);
-    packet.addReceivers(receivers);
+    Packet packet(Packet::ChallengeRequest, receivers);
     packet.write(id);
     packet.dump(device);
 }
 
-Signet::Protocol::Packet Signet::Protocol::PacketMaker::unwrap(QIODevice* device)
+void Signet::Protocol::PacketMaker::makeConnection(QIODevice* device, const QStringList& receivers)
+{
+    Packet packet(Packet::ConnectRequest, receivers);
+    packet.dump(device);
+}
+
+void Signet::Protocol::PacketMaker::dropConnection(QIODevice* device, const QStringList& receivers)
+{
+    Packet packet(Packet::DisconnectRequest, receivers);
+    packet.dump(device);
+}
+
+void Signet::Protocol::PacketMaker::unknownReceiver(QIODevice* device)
+{
+    Packet packet(Packet::UnknownReceiver);
+    packet.dump(device);
+}
+
+Signet::Protocol::Packet Signet::Protocol::PacketMaker::unwrap(QIODevice* device, ProgressMeter* progressMeter)
 {
     union
     {
@@ -75,10 +102,10 @@ Signet::Protocol::Packet Signet::Protocol::PacketMaker::unwrap(QIODevice* device
         qint16 packetType;
         qint8 sectionType;
     };
+    QStringList receivers;
     if (!readFromBuffer(raw, device, 2))
         return Packet();
     packetType = qFromBigEndian(packetType);
-    Packet packet(packetType);
     if (!readFromBuffer(raw, device, 1))
         return Packet();
     while (sectionType == Packet::Receiver)
@@ -93,7 +120,7 @@ Signet::Protocol::Packet Signet::Protocol::PacketMaker::unwrap(QIODevice* device
             delete [] buffer;
             return Packet();
         }
-        packet.addReceiver(QString::fromUtf8(buffer));
+        receivers << QString::fromUtf8(buffer);
         delete [] buffer;
         if (!readFromBuffer(raw, device, 1))
             return Packet();
@@ -102,11 +129,12 @@ Signet::Protocol::Packet Signet::Protocol::PacketMaker::unwrap(QIODevice* device
         return Packet();
     char* buffer = new char[sectionSize];
     sectionSize = qFromBigEndian(sectionSize);
-    if (!readFromBuffer(buffer, device, sectionSize))
+    if (!readFromBuffer(buffer, device, sectionSize, progressMeter))
     {
         delete [] buffer;
         return Packet();
     }
+    Packet packet(packetType, receivers);
     packet.write(QByteArray(buffer, sectionSize));
     delete [] buffer;
     return packet;
diff --git a/signet/protocol/PacketMaker.h b/signet/protocol/PacketMaker.h
index 24ab1b17..f044b20a 100644
--- a/signet/protocol/PacketMaker.h
+++ b/signet/protocol/PacketMaker.h
@@ -31,7 +31,9 @@ namespace Signet
 {
 namespace Protocol
 {
-class SIGNET_EXPORT PacketMaker
+class ProgressMeter;
+
+class SIGNET_IMPORT PacketMaker
 {
     public:
         static void rawData(QIODevice* device, const QByteArray& data, const QStringList& receivers = QStringList());
@@ -43,7 +45,12 @@ class SIGNET_EXPORT PacketMaker
         
         static void message(QIODevice* device, const QString& message, const QStringList& receivers = QStringList());
         
-        static Packet unwrap(QIODevice* device);
+        static void makeConnection(QIODevice* device, const QStringList& receivers = QStringList());
+        static void dropConnection(QIODevice* device, const QStringList& receivers = QStringList());
+        
+        static void unknownReceiver(QIODevice* device);
+        
+        static Packet unwrap(QIODevice* device, ProgressMeter* progressMeter = NULL);
 };
 }
 }
diff --git a/signet/protocol/ProgressMeter.h b/signet/protocol/ProgressMeter.h
new file mode 100644
index 00000000..9d6b0672
--- /dev/null
+++ b/signet/protocol/ProgressMeter.h
@@ -0,0 +1,39 @@
+/*
+ * 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_PROTOCOL_PROGRESSMETER
+#define SIGNET_PROTOCOL_PROGRESSMETER
+
+namespace Signet
+{
+namespace Protocol
+{
+class SIGNET_IMPORT ProgressMeter
+{
+    public:
+        virtual ~ProgressMeter();
+        
+        virtual void setExpectedSize(const int expectedSize) = 0;
+        virtual void setValue(const int value) = 0;
+        
+        virtual void success() = 0;
+        virtual void failure() = 0;
+};
+}
+}
+
+#endif