first beta

libptsocket/ptserver.cpp

 
 PTServer::PTServer(QObject *parent) : QTcpServer(parent)
 {
-	connect(this, SIGNAL(newConnection()), this, SLOT(m_newConnection()));
+    connect(this, SIGNAL(newConnection()), this, SLOT(m_newConnection()));
+}
+
+PTSocket *PTServer::nextPendingConnection()
+{
+    PTSocket* sock = 0;
+    if(!m_incomings.isEmpty())
+        sock = m_incomings.dequeue();
+    return sock;
+}
+
+void PTServer::incomingConnection(int handle)
+{
+    PTSocket* sock = new PTSocket(this);
+    sock->setIsServerSide(true);
+    sock->setSocketDescriptor(handle);
+    m_incomings.enqueue(sock);
 }
 
 void PTServer::m_newConnection()
 {
-	PTSocket* client = dynamic_cast<PTSocket*>(nextPendingConnection());
-	m_tempClients.append(client);
+    PTSocket* client = nextPendingConnection();
+    connect(client, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged(PTSocket::State)));
+    m_tempClients.append(client);
+}
+
+void PTServer::m_clientStateChanged(PTSocket::State s)
+{
+    PTSocket* client = qobject_cast<PTSocket*>(sender());
+    if(client == 0)
+        return;
+    if(s == PTSocket::Handshaked)
+    {
+        m_clients.append(client);
+        m_tempClients.removeOne(client);
+        emit newClient(client);
+    }
+    else if(s == PTSocket::Disconnected || s == PTSocket::Error)
+    {
+        m_tempClients.removeOne(client);
+        m_clients.removeOne(client);
+        client->deleteLater();
+    }
 }

libptsocket/ptserver.h

 #include <QTcpServer>
 #include <QTcpSocket>
 #include <QHostAddress>
+#include <QQueue>
 #include "ptsocket.h"
 
 class LIBPTSOCKETSHARED_EXPORT PTServer : public QTcpServer
 public:
 	explicit PTServer(QObject *parent = 0);
 
+    virtual PTSocket* nextPendingConnection();
+
+protected:
+    virtual void incomingConnection(int handle);
+
 signals:
 	void newClient(PTSocket*);
 	
 
 private slots:
 	void m_newConnection();
+    void m_clientStateChanged(PTSocket::State s);
 
 private:
 	QList<PTSocket*> m_tempClients;
 	QList<PTSocket*> m_clients;
+    QQueue<PTSocket*> m_incomings;
 	
 };
 

libptsocket/ptsocket.cpp

 
 PTSocket::PTSocket(QObject* p) : QTcpSocket(p)
 {
-	m_hasHandshaked = false;
-	m_timeout = 5000;
-	connect(&m_timeoutTimer, SIGNAL(timeout()), this, SLOT(m_handshakeError()));
-	connect(this, SIGNAL(readyRead()), this, SLOT(m_readyRead()));
+    setSocketOption(QAbstractSocket::LowDelayOption, 1);
+    m_packetSize = 0;
+    setTimeout(5000);
+    setPingInterval(1000 * 7);
+    m_state = Disconnected;
+    m_isServerSide = false;
+    connect(&m_timeoutTimer, SIGNAL(timeout()), this, SLOT(m_timedout()));
+    connect(&m_pingTimer, SIGNAL(timeout()), this, SLOT(m_ping()));
+    connect(this, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(m_stateChanged(QAbstractSocket::SocketState)));
+    connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(m_socketError(QAbstractSocket::SocketError)));
+    connect(this, SIGNAL(readyRead()), this, SLOT(m_readyRead()));
 }
 
 int PTSocket::getTimeout() const
 {
-	return m_timeout;
+    return m_timeout;
 }
 
-QByteArray PTSocket::handshakeData() const
+int PTSocket::getPingInterval() const
 {
-	return "LibPTSocket";
+    return m_pingInterval;
 }
 
-void PTSocket::handshake()
+bool PTSocket::isServerSide() const
 {
-	write(handshakeData());
+    return m_isServerSide;
+}
+
+QByteArray PTSocket::handshakeData()
+{
+    return "LibPTSocketv1";
 }
 
 void PTSocket::setTimeout(int t)
 {
-	m_timeout = t;
+    m_timeout = t;
+    if(m_timeoutTimer.isActive())
+        m_timeoutTimer.start(m_timeout);
+    else
+        m_timeoutTimer.setInterval(m_timeout);
+}
+
+void PTSocket::setPingInterval(int p)
+{
+    m_pingInterval = p;
+    if(m_pingTimer.isActive())
+        m_pingTimer.start(m_pingInterval);
+    else
+        m_pingTimer.setInterval(m_pingInterval);
+}
+
+void PTSocket::setIsServerSide(bool s)
+{
+    m_isServerSide = s;
+}
+
+void PTSocket::send(int pktType, QByteArray data)
+{
+    send(false, pktType, data);
+}
+
+void PTSocket::send(bool sys, int pktType, QByteArray data)
+{
+    if(data.isEmpty())
+        data = "\0";
+    data.prepend(intToByteArray(pktType));
+    data.prepend((char)sys);
+    data.prepend(intToByteArray(data.size()));
+    write(data);
+}
+
+void PTSocket::m_ping()
+{
+    m_pingTimer.stop();
+    if(m_timeoutTimer.isActive())
+        return;
+    send(true, PingRequest);
+    m_timeoutTimer.start();
 }
 
 void PTSocket::m_readyRead()
 {
-	if(m_hasHandshaked)
-	{
-
-	}
-	else
-	{
-		QByteArray handshake = handshakeData();
-		if(bytesAvailable() >= handshake.size())
-		{
-			QByteArray data = read(handshake.size());
-			if(data == handshake)
-			{
-				m_hasHandshaked = true;
-			}
-			else
-				m_handshakeError();
-		}
-	}
+    m_timeoutTimer.stop();
+    m_pingTimer.start();
+    if(m_state == Handshaked)
+    {
+        if(m_packetSize == 0)
+        {
+            if((unsigned)bytesAvailable() >= sizeof(int))
+                m_packetSize = byteArrayToInt(read(sizeof(int)));
+            else if(bytesAvailable() != 0)
+                m_timeoutTimer.start();
+        }
+        if(m_packetSize != 0)
+        {
+            if((unsigned)bytesAvailable() >= m_packetSize)
+            {
+                bool sys = (bool)read(1).at(0);
+                QByteArray p = read(sizeof(int));
+                int pktType = byteArrayToInt(p);
+                QByteArray data = read(m_packetSize - 1 - p.size());
+                if(sys)
+                {
+                    if(pktType == PingRequest)
+                        send(true, PingAnswer);
+                    //else if(pktType == PingAnswer)
+                }
+                else
+                    emit packetReceived(pktType, data);
+                m_packetSize = 0;
+                m_readyRead();
+            }
+            else
+                m_timeoutTimer.start();
+        }
+    }
+    else
+    {
+        QByteArray handshake = handshakeData();
+        if(bytesAvailable() >= handshake.size())
+        {
+            QByteArray data = read(handshake.size());
+            if(data == handshake)
+            {
+                setState(Handshaked);
+                m_readyRead();
+            }
+            else
+                m_handshakeError();
+        }
+        else
+            m_timeoutTimer.start();
+    }
+}
+
+void PTSocket::m_timedout()
+{
+    if(m_state == Disconnected)
+        return;
+    if(m_state == HostLookUp)
+        setError("Unable to find the host " + peerName() + " in the time (" + QString::number(m_timeout) + " ms)");
+    else if(m_state == Connecting)
+        setError("The " + QString(isServerSide()? "client " + peerAddress().toString() : "server " + peerName())  + " didn't answer to the connection request in the time (" + QString::number(m_timeout) + " ms)");
+    else if(m_state == Connected)
+        setError("The " + QString(isServerSide()? "client " + peerAddress().toString() : "server " + peerName()) + " didn't answer to the handshake in the time (" + QString::number(m_timeout) + " ms)");
+    else if(m_state == Handshaked)
+        setError("The " + QString(isServerSide()? "client " + peerAddress().toString() : "server " + peerName()) + " timed out (" + QString::number(m_timeout) + " ms)");
+    else if(m_state == Disconnecting)
+        abort();
 }
 
 void PTSocket::m_handshakeError()
 {
+    setError("The " + QString(isServerSide()? "client " + peerAddress().toString() : "server " + peerName()) + " didn't answer to the handshake correclty");
+}
+
+void PTSocket::m_stateChanged(QAbstractSocket::SocketState s)
+{
+    if(s == QAbstractSocket::HostLookupState)
+        setState(HostLookUp);
+    else if(s == QAbstractSocket::ConnectingState)
+        setState(Connecting);
+    else if(s == QAbstractSocket::ConnectedState)
+    {
+        m_packetSize = 0;
+        setState(Connected);
+        write(handshakeData());
+    }
+    else if(s == QAbstractSocket::ClosingState)
+        setState(Disconnecting);
+    m_timeoutTimer.start();
+    if(s == QAbstractSocket::UnconnectedState)
+    {
+        m_timeoutTimer.stop();
+        setState(Disconnected);
+    }
+}
 
+void PTSocket::m_socketError(QAbstractSocket::SocketError)
+{
+    setState(Error);
+}
+
+void PTSocket::setState(PTSocket::State s)
+{
+    if(s == Handshaked)
+        m_pingTimer.start();
+    else
+        m_pingTimer.stop();
+    if(m_state == Error && (s != HostLookUp && s != Connecting))
+        return;
+    m_state = s;
+    emit stateChanged(m_state);
+}
+
+void PTSocket::setError(QString e)
+{
+    if(m_state == Error)
+        return;
+    setErrorString(e);
+    setState(Error);
+}
+
+QByteArray PTSocket::intToByteArray(int a)
+{
+    QByteArray data;
+    for(unsigned char i = 0; i < sizeof(a); ++i)
+        data.append((char)(a >> 8 * i));
+    return data;
+}
+
+int PTSocket::byteArrayToInt(QByteArray d)
+{
+    int a = 0;
+    for(unsigned char i = 0; i < d.size(); ++i)
+        a |= (unsigned int)((unsigned char)d.at(i) << i * 8);
+    return a;
 }

libptsocket/ptsocket.h

 #include "libptsocket_global.h"
 #include <QObject>
 #include <QTcpSocket>
+#include <QHostAddress>
 #include <QTimer>
 
 class LIBPTSOCKETSHARED_EXPORT PTSocket : public QTcpSocket
 {
 	Q_OBJECT
 public:
+    enum State
+    {
+        Disconnected,
+        HostLookUp,
+        Connecting,
+        Connected,
+        Handshaked,
+        Disconnecting,
+        Error
+    };
 	PTSocket(QObject* p);
 	int getTimeout() const;
+    int getPingInterval() const;
+    bool isServerSide() const;
 
-	static QByteArray handshakeData() const;
+    static QByteArray handshakeData();
+
+    static QByteArray intToByteArray(int a);
+    static int byteArrayToInt(QByteArray d);
+
+signals:
+    void stateChanged(PTSocket::State);
+    void packetReceived(int, QByteArray);
 
 public slots:
-	void handshake();
 	void setTimeout(int t);
+    void setPingInterval(int p);
+    void setIsServerSide(bool s);
+    void send(int pktType, QByteArray data);
 
 private slots:
+    void m_ping();
 	void m_readyRead();
-	void m_handshakeError();
+    void m_timedout();
+    void m_handshakeError();
+    void m_stateChanged(QAbstractSocket::SocketState s);
+    void m_socketError(QAbstractSocket::SocketError);
+    void setState(State s);
+    void setError(QString e);
+    void send(bool sys, int pktType, QByteArray data = "");
 
 private:
-	bool m_hasHandshaked;
 	QTimer m_timeoutTimer;
+    QTimer m_pingTimer;
 	int m_timeout;
+    int m_pingInterval;
+    State m_state;
+    bool m_isServerSide;
+    unsigned int m_packetSize;
+    enum PacketType
+    {
+        PingRequest = 1,
+        PingAnswer = 2
+    };
 };
 
 #endif // PTSOCKET_H

tests/main.cpp

 {
 	QCoreApplication a(argc, argv);
 	Test t;
+    t.testIntConvert();
 	t.testListen(6950);
 	t.testNewConnection();
 	

tests/test.cpp

 {
 	m_serv = new PTServer(this);
 	connect(m_serv, SIGNAL(newConnection()), this, SLOT(m_newConnection()));
-	connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient(PTSocket*)));
+    connect(m_serv, SIGNAL(newClient(PTSocket*)), this, SLOT(m_newClient(PTSocket*)));
+}
+
+void Test::testIntConvert()
+{
+    QList<int> tests;
+    tests << 0 << 1 << 255 << 256 << 65535 << 65536 << -1 << -65535 << -65536 << 123456789 << -123456789;
+    for(int i = 0; i < tests.size(); ++i)
+        Q_ASSERT(PTSocket::byteArrayToInt(PTSocket::intToByteArray(tests[i])) == tests[i]);
+    qDebug()<<"Int convert OK";
 }
 
 void Test::testListen(quint16 p)
 {
 	ASSERT_LISTEN;
 	PTSocket* sock = new PTSocket(this);
+    connect(sock, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged(PTSocket::State)));
 	m_clients.append(sock);
-	sock->connectToHost("127.0.0.1", m_serv->serverPort());
+    sock->connectToHost("127.0.0.1", m_serv->serverPort());
 }
 
 void Test::m_newConnection()
 
 void Test::m_newClient(PTSocket* s)
 {
-	qDebug()<<"New client:"<<s->peerAddress()<<s->peerPort();
+    connect(s, SIGNAL(stateChanged(PTSocket::State)), this, SLOT(m_clientStateChanged(PTSocket::State)));
+    qDebug()<<"New client:"<<s->peerAddress()<<s->peerPort();
+}
+
+void Test::m_clientStateChanged(PTSocket::State s)
+{
+    PTSocket* sock = qobject_cast<PTSocket*>(sender());
+    if(sock == 0)
+        return;
+    qDebug()<<sock<<sock->isServerSide()<<s;
+    if(s == PTSocket::Error)
+        qDebug()<<sock->errorString();
 }

tests/test.h

 signals:
 	
 public slots:
+    void testIntConvert();
 	void testListen(quint16 p);
 	void testNewConnection();
 
 private slots:
 	void m_newConnection();
 	void m_newClient(PTSocket* s);
+    void m_clientStateChanged(PTSocket::State s);
 
 private:
 	PTServer* m_serv;