open_source / network

Browse Code »

Commit 99048c1cbf0e97b4906a75462ece3f7db4979387

Authored by Steven de Ridder 2022-01-24 16:09:21 +0100

0 parents

Initial commit. dependencies not resolved yet.

Inline Side-by-side

Showing 15 changed files with 1661 additions and 0 deletions

.gitignore 0 → 100644

View file @99048c1

	1	+++ a/.gitignore
	1	+build/
	2	+CMakeLists.txt.user
...	...

CMakeLists.txt 0 → 100644

View file @99048c1

	1	+++ a/CMakeLists.txt
	1	+cmake_minimum_required(VERSION 3.0)
	2	+
	3	+# Check to see where cmake is located.
	4	+if( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/cmake )
	5	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
	6	+elseif( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../cmake )
	7	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
	8	+else()
	9	+ return()
	10	+endif()
	11	+
	12	+# Check to see if there is versioning information available
	13	+if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
	14	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
	15	+ include(osdevversion)
	16	+endif()
	17	+
	18	+include(projectheader)
	19	+project_header(osdev_network)
	20	+
	21	+add_subdirectory(src)
	22	+add_subdirectory(tests)
	23	+
	24	+# include(packaging)
	25	+# package_component()
...	...

README.md 0 → 100644

View file @99048c1

	1	+++ a/README.md
...	...

src/CMakeLists.txt 0 → 100644

View file @99048c1

	1	+++ a/src/CMakeLists.txt
	1	+cmake_minimum_required(VERSION 3.0)
	2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake)
	3	+include(projectheader)
	4	+project_header(network)
	5	+
	6	+find_package( Qt5Core REQUIRED )
	7	+find_package( Qt5Network REQUIRED )
	8	+
	9	+include_directories( SYSTEM
	10	+ ${Qt5Core_INCLUDE_DIRS}
	11	+ ${Qt5Network_INCLUDE_DIRS}
	12	+)
	13	+
	14	+include(compiler)
	15	+
	16	+include_directories(
	17	+ ${CMAKE_CURRENT_SOURCE_DIR}/../config
	18	+ ${CMAKE_CURRENT_SOURCE_DIR}/../global
	19	+ ${CMAKE_CURRENT_SOURCE_DIR}/../logutils
	20	+ ${CMAKE_CURRENT_SOURCE_DIR}/../datatypes
	21	+)
	22	+
	23	+set(SRC_LIST
	24	+ ${CMAKE_CURRENT_SOURCE_DIR}/poolmanager.cpp
	25	+ ${CMAKE_CURRENT_SOURCE_DIR}/socketcontainer.cpp
	26	+ ${CMAKE_CURRENT_SOURCE_DIR}/tcpinterface.cpp
	27	+ ${CMAKE_CURRENT_SOURCE_DIR}/tcpsocket.cpp
	28	+
	29	+)
	30	+
	31	+include(qtmoc)
	32	+create_mocs( SRC_LIST MOC_LIST
	33	+ ${CMAKE_CURRENT_SOURCE_DIR}/poolmanager.h
	34	+ ${CMAKE_CURRENT_SOURCE_DIR}/tcpinterface.h
	35	+ ${CMAKE_CURRENT_SOURCE_DIR}/tcpsocket.h
	36	+)
	37	+
	38	+link_directories(
	39	+ ${CMAKE_BINARY_DIR}/lib
	40	+)
	41	+
	42	+include(library)
	43	+add_libraries(
	44	+ ${Qt5Core_LIBRARIES}
	45	+ ${Qt5Network_LIBRARIES}
	46	+ global
	47	+ logutils
	48	+ datatypes
	49	+)
	50	+
	51	+include(installation)
	52	+install_component()
...	...

src/msgparser.cpp 0 → 100644

View file @99048c1

	1	+++ a/src/msgparser.cpp
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+#include "msgparser.h"
	23	+
	24	+namespace osdev {
	25	+namespace components {
	26	+
	27	+const QString MsgParser::s_messageElementTag = "message";
	28	+const QString MsgParser::s_sourceElementTag = "source";
	29	+const QString MsgParser::s_destElementTag = "dest";
	30	+const QString MsgParser::s_actionElementTag = "action";
	31	+const QString MsgParser::s_dataElementTag = "data";
	32	+const QString MsgParser::s_idAttributeTag = "id";
	33	+
	34	+MsgParser::MsgParser(QObject* _parent)
	35	+ : QObject(_parent)
	36	+ , m_message()
	37	+ , m_sourceId()
	38	+ , m_destId()
	39	+ , m_actionId(-1)
	40	+ , m_actionData()
	41	+{
	42	+}
	43	+
	44	+MsgParser::~MsgParser()
	45	+{
	46	+}
	47	+
	48	+void MsgParser::createMsg(const QString& sourceId, const QString& destId,
	49	+ int actionId, const QString& actionData)
	50	+{
	51	+ static const QString xmlVar("<%1 %2='%3'/>");
	52	+ static const QString xmlData("<%1>%2</%1>");
	53	+ static const QString xmlMessage("<%1>%2 %3 %4 %5</%1>");
	54	+
	55	+ QString src = xmlVar.arg(s_sourceElementTag).arg(s_idAttributeTag).arg(sourceId);
	56	+ QString dst = xmlVar.arg(s_destElementTag).arg(s_idAttributeTag).arg(destId);
	57	+ QString action = xmlVar.arg(s_actionElementTag).arg(s_idAttributeTag).arg(actionId);
	58	+ QString data = xmlData.arg(s_dataElementTag).arg(actionData);
	59	+
	60	+ m_message = xmlMessage.arg(s_messageElementTag).arg(src).arg(dst).arg(action).arg(data);
	61	+}
	62	+
	63	+void MsgParser::createMsg(const QString& sourceId, const QString& destId,
	64	+ int actionId, xercesc_2_7::DOMDocument* actionData)
	65	+{
	66	+ QString msgData;
	67	+
	68	+ CXmlParser* pSerializer = new CXmlParser();
	69	+ // Store the complete message.
	70	+ msgData = pSerializer->serialize(actionData);
	71	+ delete pSerializer;
	72	+
	73	+ static const QString xmlVar("<%1 %2='%3'/>");
	74	+ static const QString xmlData("<%1>%2</%1>");
	75	+ static const QString xmlMessage("<%1>%2 %3 %4 %5</%1>");
	76	+
	77	+ QString src = xmlVar.arg(s_sourceElementTag).arg(s_idAttributeTag).arg(sourceId);
	78	+ QString dst = xmlVar.arg(s_destElementTag).arg(s_idAttributeTag).arg(destId);
	79	+ QString action = xmlVar.arg(s_actionElementTag).arg(s_idAttributeTag).arg(actionId);
	80	+ QString data = xmlData.arg(s_dataElementTag).arg(msgData);
	81	+
	82	+ m_message = xmlMessage.arg(s_messageElementTag).arg(src).arg(dst).arg(action).arg(data);
	83	+}
	84	+
	85	+void MsgParser::parseMsg(const QString& msg)
	86	+{
	87	+ CXmlParser parser;
	88	+
	89	+ DOMDocument* domDocument = parser.parse(msg);
	90	+ DOMNode* rootNode = domDocument->getDocumentElement();
	91	+
	92	+ DOMNode* node = rootNode->getFirstChild();
	93	+ if (CXerces::nodeName(node) == sourceElementTag)
	94	+ {
	95	+ m_sourceId = CXerces::getNodeAttribute(node, qPrintable(s_idAttributeTag));
	96	+ }
	97	+
	98	+ node = node->getNextSibling();
	99	+ if (CXerces::nodeName(node) == destElementTag)
	100	+ {
	101	+ m_destId = CXerces::getNodeAttribute(node, qPrintable(s_idAttributeTag));
	102	+ }
	103	+
	104	+ node = node->getNextSibling();
	105	+ if (CXerces::nodeName(node) == s_actionElementTag)
	106	+ {
	107	+ m_actionId = CXerces::getNodeAttribute(node, qPrintable(s_idAttributeTag)).toInt();
	108	+ }
	109	+
	110	+ node = node->getNextSibling();
	111	+ if (CXerces::nodeName(node) == s_dataElementTag)
	112	+ {
	113	+ m_actionData = parser.serialize(node);
	114	+ }
	115	+}
	116	+
	117	+QString MsgParser::getMsg() const
	118	+{
	119	+ return m_message;
	120	+}
	121	+
	122	+QString MsgParser::getSourceId() const
	123	+{
	124	+ return m_sourceId;
	125	+}
	126	+
	127	+QString MsgParser::getDestId() const
	128	+{
	129	+ return m_destId;
	130	+}
	131	+
	132	+int MsgParser::getActionId() const
	133	+{
	134	+ return m_actionId;
	135	+}
	136	+
	137	+QString MsgParser::getActionData() const
	138	+{
	139	+ return m_actionData;
	140	+}
	141	+
	142	+}
	143	+}
...	...

src/msgparser.h 0 → 100644

View file @99048c1

	1	+++ a/src/msgparser.h
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+//
	23	+// Description :
	24	+// Revision :
	25	+// Confidentiality :
	26	+// Dependencies :
	27	+//
	28	+
	29	+#ifndef OSDEV_COMPONENTS_CMSGPARSER_H
	30	+#define OSDEV_COMPONENTS_CMSGPARSER_H
	31	+
	32	+#include <QObject>
	33	+#include <QString>
	34	+#include <QUuid>
	35	+
	36	+namespace osdev {
	37	+namespace components {
	38	+
	39	+/**
	40	+ * @brief The MsgParser class
	41	+ */
	42	+class MsgParser : public QObject
	43	+{
	44	+ Q_OBJECT
	45	+
	46	+public:
	47	+ /**
	48	+ * @brief Constructor
	49	+ * @param _parent Parent QObject
	50	+ */
	51	+ MsgParser(QObject* _parent = nullptr);
	52	+ /// @brief Destructor
	53	+ ~MsgParser();
	54	+
	55	+ /**
	56	+ * @brief Create a message with the given parameters
	57	+ * \param sourceID The source ID of the interface calling this function.
	58	+ * \param destID The destination ID of the interface receiving the data.
	59	+ * \param actionId The action to be performed on the data.
	60	+ * \param actionData The actual data (This must be XML formatted)
	61	+ */
	62	+ void createMsg(const QString& sourceID, const QString& destID,
	63	+ int actionId, const QString& actionData);
	64	+
	65	+ /**
	66	+ * @brief Retrieve the fields from the specified message
	67	+ * @param msg Message to parse
	68	+ */
	69	+ void parseMsg(const QString& msg);
	70	+
	71	+ /// @return Message to parse
	72	+ QString getMsg() const;
	73	+ /// @return Source ID from the message
	74	+ QString getSourceId() const;
	75	+ /// @return Destination ID from the message
	76	+ QString getDestId() const;
	77	+ /// @return Action ID from the message
	78	+ int getActionId() const;
	79	+ /// @return Action data from the message
	80	+ QString getActionData() const;
	81	+
	82	+// void createMsg(const QString& sourceID, const QString& destID,
	83	+// int actionId, xercesc_2_7::DOMDocument* actionData);
	84	+
	85	+private:
	86	+ QString m_message; ///< Full message
	87	+ QString m_sourceId; ///< Source ID in the message
	88	+ QString m_destId; ///< Destination ID in the message
	89	+ int m_actionId; ///< Action ID in the message
	90	+ QString m_actionData; ///< Action Data in the message
	91	+
	92	+ static const QString s_messageElementTag;
	93	+ static const QString s_sourceElementTag;
	94	+ static const QString s_destElementTag;
	95	+ static const QString s_actionElementTag;
	96	+ static const QString s_dataElementTag;
	97	+ static const QString s_idAttributeTag;
	98	+};
	99	+
	100	+} // End namespace components
	101	+} // End namespace osdev
	102	+
	103	+#endif /* OSDEV_COMPONENTS_CMSGPARSER_H */
...	...

src/poolmanager.cpp 0 → 100644

View file @99048c1

	1	+++ a/src/poolmanager.cpp
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+#include "poolmanager.h"
	23	+#include "log.h"
	24	+#include <QCoreApplication>
	25	+
	26	+namespace osdev {
	27	+namespace components {
	28	+
	29	+PoolManager::PoolManager(bool bServer,
	30	+ const QString& ipAddress,
	31	+ int portNumber,
	32	+ int maxTcpConnections,
	33	+ int maxUdpConnections,
	34	+ QObject *_parent )
	35	+ : QObject( _parent )
	36	+ , m_pServer( nullptr )
	37	+ , m_pSocketContainer( new SocketContainer() )
	38	+ , m_pSocket( nullptr )
	39	+ , m_inputBuffer()
	40	+ , m_outputBuffer()
	41	+ , m_bServer( bServer )
	42	+ , m_ipAddress( ipAddress )
	43	+ , m_portNumber( portNumber )
	44	+ , m_maxTcpConnections( maxTcpConnections )
	45	+ , m_maxUdpConnections( maxUdpConnections )
	46	+{
	47	+}
	48	+
	49	+PoolManager::~PoolManager()
	50	+{
	51	+ delete m_pSocketContainer;
	52	+ m_pSocketContainer = nullptr;
	53	+}
	54	+/***************************************************************************
	55	+ * Server Section
	56	+ ***************************************************************************/
	57	+void PoolManager::slotNewConnection()
	58	+{
	59	+ // Create the socket, pass the pendingconnection and add it to our channelList.
	60	+
	61	+ QTcpSocket* nextConnection = m_pServer->nextPendingConnection();
	62	+ if( nextConnection )
	63	+ {
	64	+ m_pSocket = new TcpSocket( nextConnection );
	65	+ m_pSocketContainer->addSocket( m_pSocket );
	66	+
	67	+ // Connect the socket to the poolmanager
	68	+ this->connectSocketSignals( m_pSocket );
	69	+ }
	70	+}
	71	+
	72	+bool PoolManager::startNetworkLayer()
	73	+{
	74	+ bool bResult = false;
	75	+
	76	+ if( m_bServer )
	77	+ {
	78	+ m_pServer = new QTcpServer; // Create our server object
	79	+
	80	+ connect( m_pServer, SIGNAL( newConnection() ),
	81	+ this, SLOT( slotNewConnection() ) );
	82	+
	83	+ m_pServer->setMaxPendingConnections( m_maxTcpConnections );
	84	+ bResult = m_pServer->listen( QHostAddress(m_ipAddress), static_cast<quint16>(m_portNumber) );
	85	+ if( bResult )
	86	+ {
	87	+ LogDebug("interfaceplugin", "Server started");
	88	+ }
	89	+ else
	90	+ {
	91	+ LogError("interfaceplugin", "Server error : " + m_pServer->errorString());
	92	+ }
	93	+ }
	94	+ else
	95	+ {
	96	+ // Here we start a couple of client connections.
	97	+ for( int nCounter = 0; nCounter < m_maxTcpConnections; nCounter++ )
	98	+ {
	99	+ m_pSocket = new TcpSocket( m_ipAddress, m_portNumber );
	100	+ bResult = m_pSocket->isConnected();
	101	+ if( bResult )
	102	+ {
	103	+ m_pSocketContainer->addSocket( m_pSocket );
	104	+ this->connectSocketSignals( m_pSocket );
	105	+ emit message( 0, 0, osdev::components::gEventConnectionEstablished, 0 );
	106	+ }
	107	+ else
	108	+ {
	109	+ LogDebug("[PoolManager::startNetworkLayer()]", QString( "Socket Error : %1" ).arg( m_pSocket->showError() ) );
	110	+ delete m_pSocket;
	111	+ }
	112	+ }
	113	+ }
	114	+ return bResult;
	115	+}
	116	+
	117	+void PoolManager::slotDataSent( TcpSocket *pSocket )
	118	+{
	119	+ m_pSocketContainer->setChannelFree( pSocket );
	120	+
	121	+ // Check for delayed messages and send the first one.
	122	+ this->resendDelayedMessages();
	123	+}
	124	+
	125	+void PoolManager::slotReceivingData( TcpSocket *pSocket )
	126	+{
	127	+ m_pSocketContainer->setChannelBusy( pSocket );
	128	+}
	129	+
	130	+void PoolManager::slotDataReceived( const QString &sData, TcpSocket *pSocket )
	131	+{
	132	+ // Create a unique ticket
	133	+ QString l_sTicket = createBufferTicket();
	134	+
	135	+ // Store the dat with the ticket as key
	136	+ m_outputBuffer.insert( l_sTicket, sData );
	137	+
	138	+ // Free the channel.
	139	+ m_pSocketContainer->setChannelFree( pSocket );
	140	+
	141	+ // Signal the upper layer we have new data available.
	142	+ emit dataPresent( l_sTicket );
	143	+
	144	+ // Resend first delayed messages if there are any.
	145	+ this->resendDelayedMessages();
	146	+}
	147	+
	148	+void PoolManager::sendData( const QString &sData )
	149	+{
	150	+ // Get a free channel and signal the data we want to send.
	151	+ TcpSocket *pSocket = m_pSocketContainer->getFreeSocket();
	152	+ if( pSocket )
	153	+ {
	154	+ m_pSocketContainer->setChannelBusy( pSocket );
	155	+ emit signalSendData( sData, pSocket );
	156	+ QCoreApplication::processEvents();
	157	+ }
	158	+ else
	159	+ {
	160	+ LogError("NetworkInterface", QString("No free channel available. Storing for delayed send. Message number: %1").arg(m_inputBuffer.size() + 1));
	161	+ m_inputBuffer.append( sData );
	162	+ }
	163	+}
	164	+
	165	+QString PoolManager::createBufferTicket()
	166	+{
	167	+ return QUuid::createUuid().toString();
	168	+}
	169	+
	170	+QString PoolManager::getData(const QString& sTicket )
	171	+{
	172	+ if( m_outputBuffer.contains( sTicket ) )
	173	+ {
	174	+ return m_outputBuffer.take( sTicket );
	175	+ }
	176	+ else
	177	+ {
	178	+ return QString( "[ERROR : ] No data present in outputbuffer under ticket : %1 " ).arg( sTicket );
	179	+ }
	180	+}
	181	+
	182	+void PoolManager::connectSocketSignals( TcpSocket* l_pSocket)
	183	+{
	184	+ // First we connect the socket -> poolmanager
	185	+ connect( l_pSocket, SIGNAL( signalDataReceived( const QString&, TcpSocket* ) ),
	186	+ this, SLOT( slotDataReceived( const QString&, TcpSocket* ) ) );
	187	+
	188	+ connect( l_pSocket, SIGNAL( signalDataSent( TcpSocket* ) ),
	189	+ this, SLOT( slotDataSent( TcpSocket* ) ) );
	190	+
	191	+ connect( l_pSocket, SIGNAL( signalReceivingData( TcpSocket* ) ),
	192	+ this, SLOT( slotReceivingData( TcpSocket* ) ) );
	193	+
	194	+ connect( l_pSocket, SIGNAL( signalConnected( TcpSocket* ) ),
	195	+ this, SLOT( slotConnected( TcpSocket* ) ) );
	196	+
	197	+ connect( l_pSocket, SIGNAL( signalDisconnected( TcpSocket* ) ),
	198	+ this, SLOT( slotDisconnected( TcpSocket* ) ) );
	199	+
	200	+ // And now the poolmanager -> socket
	201	+ connect( this, SIGNAL( signalSendData( const QString&, TcpSocket* ) ),
	202	+ l_pSocket, SLOT( slotSendData( const QString&, TcpSocket* ) ) );
	203	+
	204	+}
	205	+
	206	+void PoolManager::resendDelayedMessages()
	207	+{
	208	+ while( m_inputBuffer.size() > 0 ) // Check for delayed messages
	209	+ {
	210	+ if( m_pSocketContainer->getFreeSocket() ) // Check if there is a free channel
	211	+ {
	212	+ // Always send the first available message (FIFO)
	213	+ this->sendData( m_inputBuffer.takeFirst() );
	214	+ LogDebug("[PoolManager::resendDelayedMessages]", QString( "Number of queued messages : %1 ").arg( m_inputBuffer.size() ) );
	215	+ }
	216	+ else
	217	+ {
	218	+ // Warn if there is a socket available....
	219	+ LogDebug( "[PoolManager::resendDelayedMessages]", QString( "No free Socket Available (yet)" ) );
	220	+ }
	221	+ }
	222	+}
	223	+
	224	+void PoolManager::slotConnected( TcpSocket *pSocket )
	225	+{
	226	+ Q_UNUSED( pSocket );
	227	+
	228	+ emit message( 0, 0, osdev::components::gEventConnectionEstablished, 0 );
	229	+}
	230	+
	231	+void PoolManager::slotDisconnected( TcpSocket *pSocket )
	232	+{
	233	+ LogError("NetworkInterface", "Socket disconnected unexpectantly.");
	234	+ LogError("NetworkInterface", pSocket->showError());
	235	+
	236	+ // emit message( 0, 0, gEventConnectionLost, 0 );
	237	+
	238	+ m_pSocketContainer->removeSocket( pSocket );
	239	+ delete pSocket;
	240	+}
	241	+
	242	+} /* End namespace components */
	243	+} /* End namespace osdev */
...	...

src/poolmanager.h 0 → 100644

View file @99048c1

	1	+++ a/src/poolmanager.h
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+#ifndef OSDEV_COMPONENTS_CPOOLMANAGER_H
	23	+#define OSDEV_COMPONENTS_CPOOLMANAGER_H
	24	+
	25	+/***************************************************************************
	26	+ * Global Includes
	27	+ ***************************************************************************/
	28	+#include <QObject>
	29	+#include <QString>
	30	+#include <QUuid>
	31	+#include <QHash>
	32	+#include <QTcpServer>
	33	+#include <QList>
	34	+
	35	+/***************************************************************************
	36	+ * Local Includes
	37	+ ***************************************************************************/
	38	+#include "eventcodes.h" // Make the codes known.
	39	+
	40	+#include "socketcontainer.h"
	41	+#include "tcpsocket.h"
	42	+
	43	+namespace osdev {
	44	+namespace components {
	45	+
	46	+/**
	47	+ * @brief Handles a pool of network connections
	48	+ */
	49	+class PoolManager : public QObject
	50	+{
	51	+ Q_OBJECT
	52	+
	53	+public:
	54	+ /**
	55	+ * @brief Constructor
	56	+ * @param bServer True for server-mode, false for client-mode (Server is default).
	57	+ * @param ipAddress IP-address to listen at (server-mode) or to connect to
	58	+ * (client-mode)
	59	+ * @param portNumber Portnumber to listen at (server-mode) or to connect to
	60	+ * (server-mode)
	61	+ * @param maxTcpConnections Maximum number of TCP connections accepted
	62	+ * @param maxUdpConnections Maximum number of UDP connections accepted
	63	+ * (currently unused)
	64	+ * @param _parent Parent object
	65	+ */
	66	+ PoolManager(bool bServer = false,
	67	+ const QString& ipAddress = "0.0.0.0",
	68	+ int portNumber = 3500,
	69	+ int maxTcpConnections = 10, // The maximum number of connections we accept.
	70	+ int maxUdpConnections = 10,
	71	+ QObject *_parent = nullptr );
	72	+
	73	+ /// @brief Destructor
	74	+ ~PoolManager();
	75	+
	76	+ /// Deleted copy-constructor
	77	+ PoolManager(const PoolManager&) = delete;
	78	+ /// Deleted assignment operator
	79	+ PoolManager& operator=(const PoolManager&) = delete;
	80	+ /// Deleted move-constructor
	81	+ PoolManager(PoolManager&&) = delete;
	82	+ /// Deleted move operator
	83	+ PoolManager& operator=(PoolManager&&) = delete;
	84	+
	85	+ /**
	86	+ * @brief Get the data for a specified ticket
	87	+ * @param sTicket Ticket ID
	88	+ * @return Available data
	89	+ */
	90	+ QString getData( const QString& sTicket );
	91	+
	92	+ /**
	93	+ * @brief Start the actual server (server-mode) or build the client
	94	+ * connection (client-mode)
	95	+ * @return True on success, false on failure
	96	+ */
	97	+ bool startNetworkLayer();
	98	+
	99	+ /**
	100	+ * @brief Send data through the interface
	101	+ * @param sData Data to send
	102	+ */
	103	+ void sendData( const QString &sData );
	104	+
	105	+public slots:
	106	+ /// @brief Slot called when a new server-connection is available
	107	+ void slotNewConnection();
	108	+
	109	+ /**
	110	+ * @brief Slot called when data was sent through the specified socket
	111	+ * @param pSocket Socket through which data was sent
	112	+ */
	113	+ void slotDataSent( TcpSocket *pSocket );
	114	+
	115	+ /**
	116	+ * @brief Slot called when data is being received by the specified socket
	117	+ * @param pSocket Socket which is receiving data
	118	+ */
	119	+ void slotReceivingData( TcpSocket *pSocket );
	120	+
	121	+ /**
	122	+ * @brief Slot called when data was received through the specified socket
	123	+ * @param sData Data received
	124	+ * @param pSocket Socket through which data was sent
	125	+ */
	126	+ void slotDataReceived( const QString &sData, TcpSocket *pSocket );
	127	+
	128	+ /**
	129	+ * @brief Slot called when the specified socket was connected
	130	+ * @param pSocket Socket through which data was sent
	131	+ */
	132	+ void slotConnected( TcpSocket *pSocket );
	133	+
	134	+ /**
	135	+ * @brief Slot called when the specified socket was disconnected
	136	+ * @param pSocket Socket that was disconnected
	137	+ *
	138	+ * Also removes the socket from the list of known sockets and deletes it
	139	+ */
	140	+ void slotDisconnected( TcpSocket *pSocket );
	141	+
	142	+signals:
	143	+ /**
	144	+ * @brief Signal emitted when data is sent through a specified socket
	145	+ * @param sData Data to be sent
	146	+ * @param pSocket Socket that sends the data
	147	+ */
	148	+ void signalSendData( const QString &sData, TcpSocket *pSocket );
	149	+
	150	+ /**
	151	+ * @brief Signal emitted when data is present for the specified ticket
	152	+ * @param sTicket Ticket ID
	153	+ */
	154	+ void dataPresent( const QString &sTicket );
	155	+
	156	+ /**
	157	+ * @brief Relay the message signal to the eventmanager
	158	+ * @todo Check parameter meanings!
	159	+ * @param i1 sourceID ?
	160	+ * @param i2 DestID ?
	161	+ * @param i3 Connection status ?
	162	+ * @param i4 data ?
	163	+ */
	164	+ void message( int i1, int i2, int i3, int i4 );
	165	+
	166	+private:
	167	+ /**
	168	+ * @brief Create a new unique buffer ticket ID
	169	+ * @return New ticket ID
	170	+ */
	171	+ QString createBufferTicket();
	172	+
	173	+ /**
	174	+ * @brief Connect all signals and slots for the socket
	175	+ * @param l_pSocket Socket to connect
	176	+ */
	177	+ void connectSocketSignals( TcpSocket *l_pSocket );
	178	+
	179	+ /// @brief Resend messages that are still in the buffer
	180	+ void resendDelayedMessages();
	181	+
	182	+ QTcpServer *m_pServer; ///< The pointer to the server object.
	183	+ SocketContainer *m_pSocketContainer; ///< Administration which keeps track of the Sockets.
	184	+ TcpSocket *m_pSocket;
	185	+
	186	+ QList< QString > m_inputBuffer; ///< Messages that can not be send yet will be stored here.
	187	+ QHash< QString, QString > m_outputBuffer; ///< The hashtable we use for databuffering.
	188	+
	189	+ bool m_bServer; ///< True for server-mode, false for client-mode
	190	+ QString m_ipAddress; ///< The ipAddress the clients are connecting to.
	191	+ int m_portNumber; ///< The portnumber our server is listening on.
	192	+ int m_maxTcpConnections;///< The number of TCP connections we accept and make.
	193	+ int m_maxUdpConnections;///< The number of UDP connections we accept and make.
	194	+};
	195	+
	196	+} // End namespace components
	197	+} // End namespace osdev
	198	+
	199	+#endif /* OSDEV_COMPONENTS_CPOOLMANAGER_H */
...	...

src/socketcontainer.cpp 0 → 100644

View file @99048c1

	1	+++ a/src/socketcontainer.cpp
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+
	23	+#include "socketcontainer.h"
	24	+
	25	+#include "tcpsocket.h"
	26	+#include "log.h"
	27	+
	28	+namespace osdev {
	29	+namespace components {
	30	+
	31	+SocketContainer::SocketContainer()
	32	+ : m_hshFreeBySocket()
	33	+{
	34	+}
	35	+
	36	+SocketContainer::~SocketContainer()
	37	+{
	38	+ // qDeleteAll( hshFreeBySocket.begin(), hshFreeBySocket.end() );
	39	+}
	40	+
	41	+void SocketContainer::addSocket( TcpSocket *pSocket )
	42	+{
	43	+ if( pSocket )
	44	+ {
	45	+ // We store a channel in a ready state.
	46	+ m_hshFreeBySocket.insert( pSocket, true );
	47	+ }
	48	+}
	49	+
	50	+void SocketContainer::removeSocket( TcpSocket *pSocket )
	51	+{
	52	+ if( pSocket )
	53	+ {
	54	+ // Remove the channel from the list.
	55	+ m_hshFreeBySocket.remove( pSocket );
	56	+ }
	57	+}
	58	+
	59	+void SocketContainer::setChannelFree( TcpSocket *pSocket )
	60	+{
	61	+ if( pSocket )
	62	+ {
	63	+ auto socketIt = m_hshFreeBySocket.find(pSocket);
	64	+ if( m_hshFreeBySocket.end() != socketIt )
	65	+ {
	66	+ socketIt.value() = true;
	67	+ }
	68	+ }
	69	+}
	70	+
	71	+void SocketContainer::setChannelBusy(TcpSocket *pSocket)
	72	+{
	73	+ if( pSocket )
	74	+ {
	75	+ auto socketIt = m_hshFreeBySocket.find(pSocket);
	76	+ if( m_hshFreeBySocket.end() != socketIt )
	77	+ {
	78	+ socketIt.value() = false;
	79	+
	80	+ // printStatus();
	81	+ }
	82	+ }
	83	+}
	84	+
	85	+TcpSocket* SocketContainer::getFreeSocket() const
	86	+{
	87	+ // printStatus();
	88	+
	89	+ // Return a random socket with a free channel
	90	+ return m_hshFreeBySocket.key( true );
	91	+}
	92	+
	93	+void SocketContainer::printStatus() const
	94	+{
	95	+ LogDebug("interfaceplugin", QString("getFreeSocket counts : ") + m_hshFreeBySocket.count());
	96	+ LogDebug("interfaceplugin", QString("==========================================================="));
	97	+
	98	+ for(auto it = m_hshFreeBySocket.begin(); it != m_hshFreeBySocket.end(); ++it)
	99	+ {
	100	+ LogDebug("interfaceplugin", it.key()->objectName()+" : "+it.value());
	101	+ }
	102	+}
	103	+
	104	+} // End namespace components
	105	+} // End namespace osdev
...	...

src/socketcontainer.h 0 → 100644

View file @99048c1

	1	+++ a/src/socketcontainer.h
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+
	23	+#ifndef OSDEV_COMPONENTS_CTHREADCONTAINER_H
	24	+#define OSDEV_COMPONENTS_CTHREADCONTAINER_H
	25	+
	26	+/***************************************************************************
	27	+ * Global Includes
	28	+ ***************************************************************************/
	29	+#include <QHash>
	30	+
	31	+/***************************************************************************
	32	+ * Local Includes
	33	+ ***************************************************************************/
	34	+
	35	+namespace osdev {
	36	+namespace components {
	37	+
	38	+class TcpSocket;
	39	+
	40	+/**
	41	+ * @brief Maintains a collection of sockets
	42	+ *
	43	+ * @note This class does NOT take ownership of the provided sockets
	44	+ */
	45	+class SocketContainer
	46	+{
	47	+public:
	48	+ /// Constructor
	49	+ SocketContainer();
	50	+ /// Destructor
	51	+ ~SocketContainer();
	52	+
	53	+ /// Deleted copy-constructor
	54	+ SocketContainer(const SocketContainer&) = delete;
	55	+ /// Deleted assignment operator
	56	+ SocketContainer& operator=(const SocketContainer&) = delete;
	57	+ /// Deleted move-constructor
	58	+ SocketContainer(SocketContainer&&) = delete;
	59	+ /// Deleted move operator
	60	+ SocketContainer& operator=(SocketContainer&&) = delete;
	61	+
	62	+ //! This function will set the given thread to free
	63	+ //! \param pSocket Socket to set to free
	64	+ void setChannelFree( TcpSocket *pSocket );
	65	+
	66	+ //! This function will set the given thread to busy
	67	+ //! \param pSocket Socket to set to busy
	68	+ void setChannelBusy( TcpSocket *pSocket );
	69	+
	70	+ //! This function will add a newly created thread to the container
	71	+ //! \param pSocket Add a new socket to the list
	72	+ void addSocket( TcpSocket *pSocket );
	73	+
	74	+ //! This function removes a thread from the list for whatever reason there might be
	75	+ //! \param pSocket Removes the socket from the list
	76	+ void removeSocket( TcpSocket *pSocket );
	77	+
	78	+ //! @return This function will return the first free thread.
	79	+ TcpSocket* getFreeSocket() const;
	80	+
	81	+private:
	82	+ /// Dump the status to debug log
	83	+ void printStatus() const;
	84	+
	85	+ /// Contains all managed sockets
	86	+ QHash< TcpSocket*, bool > m_hshFreeBySocket;
	87	+};
	88	+
	89	+} // End namespace components
	90	+} // End namespace osdev
	91	+
	92	+#endif /* OSDEV_COMPONENTS_CTHREADCONTAINER_H */
...	...

src/tcpinterface.cpp 0 → 100644

View file @99048c1

	1	+++ a/src/tcpinterface.cpp
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+
	23	+#include "tcpinterface.h"
	24	+#include "log.h"
	25	+
	26	+#include <QHostAddress>
	27	+#include <QTcpServer>
	28	+#include <QTcpSocket>
	29	+#include <QDataStream>
	30	+
	31	+namespace osdev {
	32	+namespace components {
	33	+
	34	+TcpInterface::TcpInterface(const QString& hostName, int port, bool i_bServer)
	35	+ : m_bServer( i_bServer ),
	36	+ m_active(false),
	37	+ m_tcpServer( nullptr ),
	38	+ m_tcpSocket( nullptr ),
	39	+ m_clientConnection( nullptr ),
	40	+ m_blockSize( 0 ),
	41	+ m_dataList()
	42	+{
	43	+ QHostAddress hostAddress(hostName);
	44	+
	45	+ if (m_bServer)
	46	+ { // This interface is a server
	47	+ m_tcpServer = new QTcpServer(this);
	48	+ connect(m_tcpServer, SIGNAL(newConnection()), this, SLOT(newConnection()));
	49	+ m_active = m_tcpServer->listen(hostAddress, static_cast<quint16>(port));
	50	+ if (!m_active)
	51	+ {
	52	+ LogWarning("interfaceplugin",
	53	+ "Unable to start the server: " + m_tcpServer->errorString());
	54	+ }
	55	+ }
	56	+ else
	57	+ { // This interface is a client
	58	+ m_tcpSocket = new QTcpSocket(this);
	59	+ m_tcpSocket->connectToHost(hostAddress, static_cast<quint16>(port));
	60	+ m_active = m_tcpSocket->waitForConnected(1000);
	61	+ if (m_active)
	62	+ {
	63	+ connect(m_tcpSocket, SIGNAL(readyRead()), this, SLOT(readData()));
	64	+ }
	65	+ }
	66	+}
	67	+
	68	+
	69	+TcpInterface::~TcpInterface()
	70	+{
	71	+}
	72	+
	73	+QString TcpInterface::getData()
	74	+{
	75	+ QString qsResult;
	76	+ if(!m_dataList.isEmpty())
	77	+ {
	78	+ qsResult = m_dataList.takeFirst();
	79	+ }
	80	+ return qsResult;
	81	+}
	82	+
	83	+void TcpInterface::readData()
	84	+{
	85	+ QTcpSocket* pSocket = nullptr;
	86	+ /* Retrieve the correct Socket, depending on connection-type */
	87	+ if (m_bServer)
	88	+ {
	89	+ pSocket = m_clientConnection;
	90	+ }
	91	+ else
	92	+ {
	93	+ pSocket = m_tcpSocket;
	94	+ }
	95	+
	96	+ /* Construct a DataStream from the Socket */
	97	+ QDataStream in(pSocket);
	98	+ in.setVersion(QDataStream::Qt_5_4);
	99	+
	100	+ // Process while there is a following message in this same buffer.
	101	+ do {
	102	+ LogDebug("TcpInterface", "read bytes");
	103	+ /* The size of the message in bytes is required */
	104	+ if (m_blockSize == 0)
	105	+ {
	106	+ /*
	107	+ * The size of the message should be available as the first four
	108	+ * blocks of the message; i.e. (sizeof(quint32))
	109	+ */
	110	+ if (pSocket->bytesAvailable() < static_cast<int>(sizeof(quint32)))
	111	+ {
	112	+ return;
	113	+ }
	114	+ /* Retrieve the blocksize if it is fully available from the socket */
	115	+ in >> m_blockSize;
	116	+ LogDebug("TcpInterface", QString("block size is %1").arg(m_blockSize));
	117	+ }
	118	+
	119	+ if (pSocket->bytesAvailable() < m_blockSize)
	120	+ {
	121	+ return;
	122	+ }
	123	+
	124	+ /*
	125	+ * Retrieve the message if it is completely available from the socket.
	126	+ * I.e.: The number of available bytes must be at least the retrieved
	127	+ * message-size.
	128	+ */
	129	+ QByteArray pDataStore;
	130	+ /*
	131	+ * Using an empty QByteArray the operator>> can be used, because it then
	132	+ * reads in everything until the first '\0' character.
	133	+ * It is then required that all messages are ended by a '\0'. This is
	134	+ * standard when sending QByteArrays.
	135	+ */
	136	+ in >> pDataStore;
	137	+ /*
	138	+ * An entire message is stored in a new QByteArray and must be pushed on
	139	+ * the stack of available messages
	140	+ */
	141	+ m_dataList.append( pDataStore );
	142	+ m_blockSize = 0; // reset blocksize for next read
	143	+ emit dataPresent();
	144	+ } while (pSocket->bytesAvailable() > 0);
	145	+}
	146	+
	147	+void TcpInterface::sendData(const QString& i_qsData)
	148	+{
	149	+ QByteArray block;
	150	+ QDataStream out(&block, QIODevice::WriteOnly);
	151	+
	152	+ out.setVersion(QDataStream::Qt_5_4);
	153	+
	154	+ out << block.size();
	155	+ out << i_qsData.toLatin1();
	156	+
	157	+ if (m_bServer)
	158	+ {
	159	+ m_clientConnection->write(block);
	160	+ m_clientConnection->flush();
	161	+ }
	162	+ else
	163	+ {
	164	+ m_tcpSocket->write(block);
	165	+ m_tcpSocket->flush();
	166	+ }
	167	+}
	168	+
	169	+void TcpInterface::newConnection()
	170	+{
	171	+ m_clientConnection = m_tcpServer->nextPendingConnection();
	172	+ connect(m_clientConnection, SIGNAL(readyRead()), this, SLOT(readData()));
	173	+}
	174	+
	175	+}
	176	+}
...	...

src/tcpinterface.h 0 → 100644

View file @99048c1

	1	+++ a/src/tcpinterface.h
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+
	23	+#ifndef OSDEV_COMPONENTS_CTCPINTERFACE_H
	24	+#define OSDEV_COMPONENTS_CTCPINTERFACE_H
	25	+
	26	+#include <QObject>
	27	+#include <QList>
	28	+
	29	+class QTcpServer;
	30	+class QTcpSocket;
	31	+
	32	+namespace osdev {
	33	+namespace components {
	34	+
	35	+/**
	36	+ * @brief Handles a generic client or server point-to-point connection
	37	+ *
	38	+ * This class can be instantiated as a client or a server.
	39	+ *
	40	+ * @note The server can currently only handle one client at a time.
	41	+ */
	42	+class TcpInterface : public QObject
	43	+{
	44	+ Q_OBJECT
	45	+
	46	+public:
	47	+ /**
	48	+ * @brief Constructor
	49	+ * @param hostName Host to connect with (client-mode), or interface to
	50	+ * connect at (server-mode)
	51	+ * @param port Selected port-number
	52	+ * @param i_bServer False for client-mode, true for server-mode
	53	+ */
	54	+ TcpInterface(const QString& hostName, int port = 2776, bool i_bServer = false);
	55	+ /// @brief Destructor
	56	+ ~TcpInterface();
	57	+
	58	+ /// Deleted copy-constructor
	59	+ TcpInterface(const TcpInterface&) = delete;
	60	+ /// Deleted assignment operator
	61	+ TcpInterface& operator=(const TcpInterface&) = delete;
	62	+ /// Deleted move-constructor
	63	+ TcpInterface(TcpInterface&&) = delete;
	64	+ /// Deleted move operator
	65	+ TcpInterface& operator=(TcpInterface&&) = delete;
	66	+
	67	+ /**
	68	+ * @return if the interface is active.
	69	+ * In server mode the interface is listening or connected to and in
	70	+ * client mode the interface is connected.
	71	+ */
	72	+ bool active() const
	73	+ {
	74	+ return m_active;
	75	+ }
	76	+
	77	+ /**
	78	+ * @brief Reads the first block of data from the received data
	79	+ * @return First block of data, as a QString
	80	+ */
	81	+ QString getData();
	82	+
	83	+public slots:
	84	+
	85	+ /**
	86	+ * @brief Called when data is ready to be read into the buffer
	87	+ */
	88	+ void readData();
	89	+
	90	+ /**
	91	+ * @brief Send a block of data to the other party
	92	+ * @param i_qsData Data to be sent
	93	+ */
	94	+ void sendData(const QString& i_qsData);
	95	+
	96	+signals:
	97	+ /// @brief Emitted when data is present on the connection
	98	+ void dataPresent();
	99	+
	100	+private slots:
	101	+ /// @brief Slot called when a new connection is made
	102	+ void newConnection();
	103	+
	104	+private:
	105	+ bool m_bServer; ///< True for server-mode, false for client-mode
	106	+ bool m_active; ///< True if in server mode the server is listening or connected to and in client mode when the client is connected.
	107	+
	108	+ QTcpServer* m_tcpServer; ///< Server object instance
	109	+ QTcpSocket* m_tcpSocket; ///< Client object instance
	110	+
	111	+ QTcpSocket* m_clientConnection; ///< Current client connection
	112	+
	113	+ quint32 m_blockSize; ///< Maximum size of a data-block
	114	+ QList<QByteArray> m_dataList; ///< Blocks of data read from the counterpart
	115	+};
	116	+
	117	+} // End namespace components
	118	+} // End namespace osdev
	119	+
	120	+#endif /* OSDEV_COMPONENTS_CTCPINTERFACE_H */
...	...

src/tcpsocket.cpp 0 → 100644

View file @99048c1

	1	+++ a/src/tcpsocket.cpp
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+#include "tcpsocket.h"
	23	+
	24	+#include "log.h"
	25	+
	26	+#include <QHostAddress>
	27	+#include <QTcpSocket>
	28	+#include <QTimer>
	29	+#include <QDataStream>
	30	+
	31	+namespace osdev {
	32	+namespace components {
	33	+
	34	+TcpSocket::TcpSocket( const QString& ipAddress, int portNumber )
	35	+ : m_pSocket(new QTcpSocket(this))
	36	+ , m_blockSize(0)
	37	+ , m_dataBuffer()
	38	+ , m_pTimer( new QTimer() )
	39	+{
	40	+ // First we connect the timer to this class
	41	+ connect(m_pTimer.get(), SIGNAL(timeout()), this, SLOT(chkSendBuffer()));
	42	+
	43	+ this->connectSocketSignals();
	44	+
	45	+ m_pSocket->connectToHost( QHostAddress( ipAddress ), static_cast<quint16>(portNumber) );
	46	+ if( !m_pSocket->waitForConnected( 3000 ) )
	47	+ {
	48	+ LogDebug("interfaceplugin", "Socket failed to connect.");
	49	+ LogObject("interfaceplugin", this);
	50	+ }
	51	+ else
	52	+ {
	53	+ LogDebug("interfaceplugin", "Client connected : ");
	54	+ LogObject("interfaceplugin", m_pSocket);
	55	+ }
	56	+}
	57	+
	58	+TcpSocket::TcpSocket(QTcpSocket *pSocket)
	59	+ : m_pSocket(pSocket)
	60	+ , m_blockSize(0)
	61	+ , m_dataBuffer()
	62	+ , m_pTimer( new QTimer() )
	63	+{
	64	+ Q_ASSERT(pSocket);
	65	+
	66	+ connect(m_pTimer.get(), SIGNAL(timeout()), this, SLOT(chkSendBuffer()));
	67	+
	68	+ this->connectSocketSignals();
	69	+}
	70	+
	71	+TcpSocket::~TcpSocket()
	72	+{
	73	+ // Implicitly deletes m_pSocket if this object is its parent
	74	+}
	75	+
	76	+void TcpSocket::slotReadyRead()
	77	+{
	78	+ // Let the poolmanager know we are busy receiving data at the moment and are
	79	+ // unavailable for anything else.
	80	+ emit signalReceivingData( this );
	81	+
	82	+ QDataStream in( m_pSocket );
	83	+ in.setVersion( QDataStream::Qt_5_4 );
	84	+
	85	+ if( m_blockSize == 0 )
	86	+ {
	87	+ if( m_pSocket->bytesAvailable() < static_cast<int>(sizeof( quint32 ) ) )
	88	+ {
	89	+ return;
	90	+ }
	91	+
	92	+ in >> m_blockSize;
	93	+ }
	94	+
	95	+ if( m_pSocket->bytesAvailable() < m_blockSize )
	96	+ {
	97	+ return;
	98	+ }
	99	+
	100	+ in >> m_dataBuffer;
	101	+
	102	+ emit signalDataReceived( m_dataBuffer, this );
	103	+
	104	+ m_blockSize = 0; // Reset the blockSize for next read.
	105	+ m_dataBuffer.clear(); // Reset the buffer for the next read.
	106	+}
	107	+
	108	+void TcpSocket::slotSendData( const QString &sData, TcpSocket *pSocket )
	109	+{
	110	+ if( pSocket != this \|\| sData.isNull() ) {
	111	+ return;
	112	+ }
	113	+
	114	+ QByteArray block;
	115	+ QDataStream out( &block, QIODevice::WriteOnly );
	116	+
	117	+ out.setVersion( QDataStream::Qt_5_4 );
	118	+ out << block.size();
	119	+ out << sData;
	120	+
	121	+ m_pSocket->write( block );
	122	+ chkSendBuffer();
	123	+}
	124	+
	125	+void TcpSocket::slotSetSocket(QTcpSocket* pSocket )
	126	+{
	127	+ if(m_pSocket) {
	128	+ disconnectSocketSignals();
	129	+ }
	130	+ m_pSocket = pSocket;
	131	+ connectSocketSignals();
	132	+}
	133	+
	134	+void TcpSocket::chkSendBuffer()
	135	+{
	136	+ m_pTimer->stop();
	137	+
	138	+ if( m_pSocket->bytesToWrite() > 0 )
	139	+ {
	140	+ m_pSocket->flush();
	141	+ m_pTimer->start( 500 );
	142	+ }
	143	+ else
	144	+ {
	145	+ emit signalDataSent( this );
	146	+ }
	147	+}
	148	+
	149	+void TcpSocket::slotConnected()
	150	+{
	151	+ emit signalConnected( this );
	152	+}
	153	+
	154	+void TcpSocket::slotDisconnected()
	155	+{
	156	+ emit signalDisconnected( this );
	157	+}
	158	+
	159	+QString TcpSocket::showError()
	160	+{
	161	+ if( m_pSocket )
	162	+ {
	163	+ return m_pSocket->errorString();
	164	+ }
	165	+ else
	166	+ {
	167	+ return "No socket available";
	168	+ }
	169	+}
	170	+
	171	+void TcpSocket::connectSocketSignals()
	172	+{
	173	+ Q_ASSERT(m_pSocket);
	174	+ // Connect the required signals and slots to gain control.
	175	+ // First for receiving data.
	176	+ connect( m_pSocket, SIGNAL( readyRead() ),
	177	+ this, SLOT( slotReadyRead() ) );
	178	+
	179	+ connect( m_pSocket, SIGNAL( connected() ),
	180	+ this, SLOT( slotConnected() ) );
	181	+
	182	+ connect( m_pSocket, SIGNAL( disconnected() ),
	183	+ this, SLOT( slotDisconnected() ) );
	184	+}
	185	+
	186	+void TcpSocket::disconnectSocketSignals()
	187	+{
	188	+ Q_ASSERT(m_pSocket);
	189	+ // Connect the required signals and slots to gain control.
	190	+ // First for receiving data.
	191	+ disconnect( m_pSocket, SIGNAL( readyRead() ),
	192	+ this, SLOT( slotReadyRead() ) );
	193	+
	194	+ disconnect( m_pSocket, SIGNAL( connected() ),
	195	+ this, SLOT( slotConnected() ) );
	196	+
	197	+ disconnect( m_pSocket, SIGNAL( disconnected() ),
	198	+ this, SLOT( slotDisconnected() ) );
	199	+}
	200	+
	201	+bool TcpSocket::isConnected()
	202	+{
	203	+ return m_pSocket && m_pSocket->state() == QTcpSocket::ConnectedState;
	204	+}
	205	+
	206	+}
	207	+}
...	...

src/tcpsocket.h 0 → 100644

View file @99048c1

	1	+++ a/src/tcpsocket.h
	1	+/* ****************************************************************************
	2	+ * Copyright 2019 Open Systems Development BV *
	3	+ * *
	4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
	5	+ * copy of this software and associated documentation files (the "Software"), *
	6	+ * to deal in the Software without restriction, including without limitation *
	7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
	8	+ * and/or sell copies of the Software, and to permit persons to whom the *
	9	+ * Software is furnished to do so, subject to the following conditions: *
	10	+ * *
	11	+ * The above copyright notice and this permission notice shall be included in *
	12	+ * all copies or substantial portions of the Software. *
	13	+ * *
	14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
	15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
	16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
	17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
	18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
	19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
	20	+ * DEALINGS IN THE SOFTWARE. *
	21	+ * ***************************************************************************/
	22	+
	23	+#ifndef OSDEV_COMPONENTS_CTCPSOCKET_H
	24	+#define OSDEV_COMPONENTS_CTCPSOCKET_H
	25	+
	26	+#include <QObject>
	27	+//#include <QTimer>
	28	+//#include <QTcpSocket>
	29	+//#include <QHostAddress>
	30	+//#include <QDataStream>
	31	+//#include <QString>
	32	+
	33	+#include <memory>
	34	+
	35	+class QTcpSocket;
	36	+class QTimer;
	37	+
	38	+namespace osdev {
	39	+namespace components {
	40	+
	41	+/**
	42	+ * @brief Wrapper around QTcpSocket
	43	+ */
	44	+class TcpSocket : public QObject
	45	+{
	46	+ Q_OBJECT
	47	+
	48	+public:
	49	+ /**
	50	+ * @brief Create a TcpSocket connecting to the given address
	51	+ * @param ipAddress Host to connect to
	52	+ * @param portNumber Port number to connect at
	53	+ */
	54	+ TcpSocket( const QString& ipAddress, int portNumber );
	55	+
	56	+ /**
	57	+ * @brief Create a TcpSocket based on an existing QTcpSocket
	58	+ * @param pSocket Socket used. This class does NOT take ownership of the
	59	+ * provided socket.
	60	+ */
	61	+ TcpSocket( QTcpSocket *pSocket );
	62	+
	63	+ /// Deleted copy-constructor
	64	+ TcpSocket(const TcpSocket&) = delete;
	65	+ /// Deleted assignment operator
	66	+ TcpSocket& operator=(const TcpSocket&) = delete;
	67	+ /// Deleted move-constructor
	68	+ TcpSocket(TcpSocket&&) = delete;
	69	+ /// Deleted move operator
	70	+ TcpSocket& operator=(TcpSocket&&) = delete;
	71	+
	72	+ /// @brief Destructor
	73	+ ~TcpSocket();
	74	+
	75	+ /**
	76	+ * @brief Retrieve the last error registered in the socket
	77	+ * @return Error string
	78	+ */
	79	+ QString showError();
	80	+
	81	+ /**
	82	+ * @brief See if a connection is available
	83	+ * @return True if a connection is available, false otherwise
	84	+ */
	85	+ bool isConnected();
	86	+
	87	+public slots:
	88	+ /**
	89	+ * @brief Slot called to send data
	90	+ * @param sData Data to send
	91	+ * @param pSocket Socket to which to send. If it is not equal to this, the
	92	+ * slot does nothing and returns
	93	+ */
	94	+ void slotSendData( const QString &sData, TcpSocket *pSocket );
	95	+
	96	+ /**
	97	+ * @brief Updates the current QTcpSocket used
	98	+ * @param pSocket New socket
	99	+ */
	100	+ void slotSetSocket( QTcpSocket *pSocket );
	101	+
	102	+ /// @brief Slot called when a socket gets connected
	103	+ void slotConnected();
	104	+
	105	+ /// @brief Slot called when a socket gets disconnected
	106	+ void slotDisconnected();
	107	+
	108	+signals:
	109	+ /**
	110	+ * @brief Signal emitted when data is received
	111	+ * @param sData Block of data received
	112	+ * @param pSocket Receiving socket
	113	+ */
	114	+ void signalDataReceived( const QString &sData, TcpSocket *pSocket );
	115	+
	116	+ /**
	117	+ * @brief Signal emitted when data was sent
	118	+ * @param pSocket Sending socket
	119	+ */
	120	+ void signalDataSent( TcpSocket *pSocket );
	121	+
	122	+ /**
	123	+ * @brief Signal emitted when data is being received
	124	+ * @param pSocket Receiving socket
	125	+ */
	126	+ void signalReceivingData( TcpSocket *pSocket );
	127	+
	128	+ /**
	129	+ * @brief Signal emitted when a socket gets connected
	130	+ * @param pSocket Socket that gets connected
	131	+ */
	132	+ void signalConnected( TcpSocket *pSocket );
	133	+
	134	+ /**
	135	+ * @brief Signal emitted when a socket gets disconnected
	136	+ * @param pSocket Socket that gets disconnected
	137	+ */
	138	+ void signalDisconnected( TcpSocket *pSocket );
	139	+
	140	+private slots:
	141	+ /// @brief Slot called when a socket is ready to read
	142	+ void slotReadyRead();
	143	+
	144	+ /// @brief Emits the signalDataSent when all data was sent
	145	+ void chkSendBuffer();
	146	+
	147	+private:
	148	+ /// @brief Connects the socket signals to the slots of this class
	149	+ void connectSocketSignals();
	150	+
	151	+ /// @brief Disconnects the socket signals to the slots of this class
	152	+ void disconnectSocketSignals();
	153	+
	154	+ QTcpSocket *m_pSocket; ///< Current communication socket
	155	+ int m_blockSize; ///< Maximum block size
	156	+ QString m_dataBuffer; ///< Data to be sent
	157	+
	158	+ std::unique_ptr<QTimer> m_pTimer; ///< Periodic check if all data was sent
	159	+};
	160	+
	161	+} // End namespace components
	162	+} // End namespace osdev
	163	+
	164	+#endif // OSDEV_COMPONENTS_CTCPSOCKET_H
...	...

tests/CMakeLists.txt 0 → 100644

View file @99048c1

	1	+++ a/tests/CMakeLists.txt
	1	+cmake_minimum_required(VERSION 3.0)
	2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
	3	+
	4	+include(projectheader)
	5	+project_header(test_logutils)
	6	+
	7	+include_directories( SYSTEM
	8	+ ${CMAKE_CURRENT_SOURCE_DIR}/../../src
	9	+)
	10	+
	11	+include(compiler)
	12	+set(SRC_LIST
	13	+)
	14	+
	15	+# add_executable( ${PROJECT_NAME}
	16	+# ${SRC_LIST}
	17	+# )
	18	+
	19	+# target_link_libraries(
	20	+# ${PROJECT_NAME}
	21	+# )
	22	+
	23	+# set_target_properties( ${PROJECT_NAME} PROPERTIES
	24	+# RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
	25	+# LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
	26	+# ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/archive
	27	+# )
	28	+
	29	+# include(installation)
	30	+# install_application()
...	...