Support TCP for protocol messages

Jamulus.pro

@@ -399,6 +399,8 @@ HEADERS += src/plugins/audioreverb.h \
     src/serverlogging.h \
     src/settings.h \
     src/socket.h \
+    src/tcpserver.h \
+    src/tcpconnection.h \
     src/util.h \
     src/recorder/jamrecorder.h \
     src/recorder/creaperproject.h \
@@ -507,6 +509,8 @@ SOURCES += src/plugins/audioreverb.cpp \
     src/settings.cpp \
     src/signalhandler.cpp \
     src/socket.cpp \
+    src/tcpserver.cpp \
+    src/tcpconnection.cpp \
     src/util.cpp \
     src/recorder/jamrecorder.cpp \
     src/recorder/creaperproject.cpp \

src/channel.cpp

@@ -48,6 +48,7 @@
 
 // CChannel implementation *****************************************************
 CChannel::CChannel ( const bool bNIsServer ) :
+    pTcpConnection ( nullptr ),
     vecfGains ( MAX_NUM_CHANNELS, 1.0f ),
     vecfPannings ( MAX_NUM_CHANNELS, 0.5f ),
     iCurSockBufNumFrames ( INVALID_INDEX ),
@@ -103,7 +104,7 @@ CChannel::CChannel ( const bool bNIsServer ) :
 
     QObject::connect ( &Protocol, &CProtocol::ChangeChanPan, this, &CChannel::OnChangeChanPan );
 
-    QObject::connect ( &Protocol, &CProtocol::ClientIDReceived, this, &CChannel::ClientIDReceived );
+    QObject::connect ( &Protocol, &CProtocol::ClientIDReceived, this, &CChannel::OnClientIDReceived );
 
     QObject::connect ( &Protocol, &CProtocol::RawAudioSupported, this, &CChannel::RawAudioSupported );
 
@@ -736,3 +737,25 @@ void CChannel::UpdateSocketBufferSize()
         SetSockBufNumFrames ( SockBuf.GetAutoSetting(), true );
     }
 }
+
+void CChannel::OnClientIDReceived ( int iChanID )
+{
+    qDebug() << Q_FUNC_INFO << "iChanID =" << iChanID;
+    emit ClientIDReceived ( iChanID );
+}
+
+void CChannel::CreateConClientListMes ( const CVector<CChannelInfo>& vecChanInfo, CProtocol& ConnLessProtocol )
+{
+    if ( pTcpConnection )
+    {
+        qDebug() << "- sending client list via TCP";
+
+        ConnLessProtocol.CreateCLConnClientsListMes ( InetAddr, vecChanInfo, pTcpConnection );
+    }
+    else
+    {
+        qDebug() << "- sending client list via UDP";
+
+        Protocol.CreateConClientListMes ( vecChanInfo );
+    }
+}

src/channel.h

@@ -108,6 +108,9 @@ class CChannel : public QObject
     void                SetAddress ( const CHostAddress& NAddr ) { InetAddr = NAddr; }
     const CHostAddress& GetAddress() const { return InetAddr; }
 
+    void            SetTcpConnection ( CTcpConnection* pConnection ) { pTcpConnection = pConnection; }
+    CTcpConnection* GetTcpConnection() { return pTcpConnection; }
+
     void ResetInfo()
     {
         bIsIdentified = false;
@@ -184,7 +187,7 @@ class CChannel : public QObject
     void CreateReqChannelLevelListMes() { Protocol.CreateReqChannelLevelListMes(); }
     //### TODO: END ###//
 
-    void CreateConClientListMes ( const CVector<CChannelInfo>& vecChanInfo ) { Protocol.CreateConClientListMes ( vecChanInfo ); }
+    void CreateConClientListMes ( const CVector<CChannelInfo>& vecChanInfo, CProtocol& ConnLessProtocol );
 
     void CreateRecorderStateMes ( const ERecorderState eRecorderState ) { Protocol.CreateRecorderStateMes ( eRecorderState ); }
 
@@ -209,7 +212,8 @@ class CChannel : public QObject
     }
 
     // connection parameters
-    CHostAddress InetAddr;
+    CHostAddress    InetAddr;
+    CTcpConnection* pTcpConnection;
 
     // channel info
     CChannelCoreInfo ChannelInfo;
@@ -278,11 +282,12 @@ public slots:
         PutProtocolData ( iRecCounter, iRecID, vecbyMesBodyData, RecHostAddr );
     }
 
-    void OnProtocolCLMessageReceived ( int iRecID, CVector<uint8_t> vecbyMesBodyData, CHostAddress RecHostAddr )
+    void OnProtocolCLMessageReceived ( int iRecID, CVector<uint8_t> vecbyMesBodyData, CHostAddress RecHostAddr, CTcpConnection* pTcpConnection )
     {
-        emit DetectedCLMessage ( vecbyMesBodyData, iRecID, RecHostAddr );
+        emit DetectedCLMessage ( vecbyMesBodyData, iRecID, RecHostAddr, pTcpConnection );
     }
 
+    void OnClientIDReceived ( int iChanID );
     void OnNewConnection() { emit NewConnection(); }
 
 signals:
@@ -306,7 +311,7 @@ public slots:
     void RecorderStateReceived ( ERecorderState eRecorderState );
     void Disconnected();
 
-    void DetectedCLMessage ( CVector<uint8_t> vecbyMesBodyData, int iRecID, CHostAddress RecHostAddr );
+    void DetectedCLMessage ( CVector<uint8_t> vecbyMesBodyData, int iRecID, CHostAddress RecHostAddr, CTcpConnection* pTcpConnection );
 
     void ParseMessageBody ( CVector<uint8_t> vecbyMesBodyData, int iRecCounter, int iRecID );
 };

src/client.cpp

@@ -169,7 +169,9 @@ CClient::CClient ( const quint16  iPortNumber,
 
     QObject::connect ( &ConnLessProtocol, &CProtocol::CLRedServerListReceived, this, &CClient::CLRedServerListReceived );
 
-    QObject::connect ( &ConnLessProtocol, &CProtocol::CLConnClientsListMesReceived, this, &CClient::CLConnClientsListMesReceived );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLTcpSupportedReceived, this, &CClient::OnCLTcpSupportedReceived );
+
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLConnClientsListMesReceived, this, &CClient::OnCLConnClientsListMesReceived );
 
     QObject::connect ( &ConnLessProtocol, &CProtocol::CLPingReceived, this, &CClient::OnCLPingReceived );
 
@@ -266,11 +268,81 @@ void CClient::OnSendProtMessage ( CVector<uint8_t> vecMessage )
     Socket.SendPacket ( vecMessage, Channel.GetAddress() );
 }
 
-void CClient::OnSendCLProtMessage ( CHostAddress InetAddr, CVector<uint8_t> vecMessage )
+void CClient::OnSendCLProtMessage ( CHostAddress InetAddr, CVector<uint8_t> vecMessage, CTcpConnection* pTcpConnection, enum EProtoMode eProtoMode )
 {
+    if ( pTcpConnection )
+    {
+        // already have TCP connection - just send and return
+        pTcpConnection->write ( (const char*) &( (CVector<uint8_t>) vecMessage )[0], vecMessage.Size() );
+        return;
+    }
+
     // the protocol queries me to call the function to send the message
     // send it through the network
-    Socket.SendPacket ( vecMessage, InetAddr );
+    if ( eProtoMode != PROTO_UDP )
+    {
+        // create a TCP client connection and send message
+        QTcpSocket* pSocket = new QTcpSocket ( this );
+
+        // timer for TCP connect timeout because Qt defaults to 30 seconds
+        // and we want it to be 3 seconds (TCP_CONNECT_TIMEOUT_MS)
+        QTimer* pTimer = new QTimer ( this );
+        pTimer->setSingleShot ( true );
+
+        connect ( pTimer, &QTimer::timeout, this, [this, pSocket, pTimer, InetAddr]() {
+            if ( pSocket->state() != QAbstractSocket::ConnectedState )
+            {
+                pSocket->abort();
+                pSocket->deleteLater();
+                qWarning() << "- Jamulus-TCP: timeout connecting to" << InetAddr.toString();
+            }
+            pTimer->deleteLater();
+        } );
+
+#if QT_VERSION >= QT_VERSION_CHECK( 5, 15, 0 )
+#    define ERRORSIGNAL &QTcpSocket::errorOccurred
+#else
+#    define ERRORSIGNAL QOverload<QAbstractSocket::SocketError>::of ( &QAbstractSocket::error )
+#endif
+        connect ( pSocket, ERRORSIGNAL, this, [this, pSocket, pTimer] ( QAbstractSocket::SocketError err ) {
+            Q_UNUSED ( err );
+
+            pTimer->stop();
+            pTimer->deleteLater();
+
+            qWarning() << "- TCP connection error:" << pSocket->errorString();
+            // may want to specifically handle ConnectionRefusedError?
+            pSocket->deleteLater();
+        } );
+
+        connect ( pSocket, &QTcpSocket::connected, this, [this, pSocket, pTimer, InetAddr, vecMessage, eProtoMode]() {
+            pTimer->stop();
+            pTimer->deleteLater();
+
+            // connection succeeded, give it to a CTcpConnection
+            CTcpConnection* pTcpConnection = new CTcpConnection ( pSocket,
+                                                                  InetAddr,
+                                                                  this,
+                                                                  &Channel,
+                                                                  eProtoMode == PROTO_TCP_LONG ); // client connection, will self-delete on disconnect
+
+            if ( eProtoMode == PROTO_TCP_LONG )
+            {
+                Channel.SetTcpConnection ( pTcpConnection ); // link session connection with channel
+            }
+
+            pTcpConnection->write ( (const char*) &( (CVector<uint8_t>) vecMessage )[0], vecMessage.Size() );
+
+            // the CTcpConnection object will pass the reply back up to CClient::Channel
+        } );
+
+        pSocket->connectToHost ( InetAddr.InetAddr, InetAddr.iPort );
+        pTimer->start ( TCP_CONNECT_TIMEOUT_MS );
+    }
+    else
+    {
+        Socket.SendPacket ( vecMessage, InetAddr );
+    }
 }
 
 void CClient::OnInvalidPacketReceived ( CHostAddress RecHostAddr )
@@ -285,10 +357,10 @@ void CClient::OnInvalidPacketReceived ( CHostAddress RecHostAddr )
     }
 }
 
-void CClient::OnDetectedCLMessage ( CVector<uint8_t> vecbyMesBodyData, int iRecID, CHostAddress RecHostAddr )
+void CClient::OnDetectedCLMessage ( CVector<uint8_t> vecbyMesBodyData, int iRecID, CHostAddress RecHostAddr, CTcpConnection* pTcpConnection )
 {
     // connection less messages are always processed
-    ConnLessProtocol.ParseConnectionLessMessageBody ( vecbyMesBodyData, iRecID, RecHostAddr );
+    ConnLessProtocol.ParseConnectionLessMessageBody ( vecbyMesBodyData, iRecID, RecHostAddr, pTcpConnection );
 }
 
 void CClient::OnJittBufSizeChanged ( int iNewJitBufSize )
@@ -992,6 +1064,16 @@ void CClient::OnClientIDReceived ( int iServerChanID )
         ClearClientChannels();
     }
 
+    // if TCP Supported has already been received, make TCP connection to server
+    iClientID = iServerChanID; // for sending back to server over TCP
+
+    if ( bTcpSupported )
+    {
+        // *** Make TCP connection
+        qDebug() << Q_FUNC_INFO << "need to make TCP connection for" << iClientID;
+        ConnLessProtocol.CreateCLClientIDMes ( Channel.GetAddress(), iClientID, PROTO_TCP_LONG ); // create persistent TCP connection
+    }
+
     // allocate and map client-side channel 0
     int iChanID = FindClientChannel ( iServerChanID, true ); // should always return channel 0
 
@@ -1027,11 +1109,52 @@ void CClient::OnRawAudioSupported()
     }
 }
 
+void CClient::OnCLTcpSupportedReceived ( CHostAddress InetAddr, int iID )
+{
+    qDebug() << "- TCP supported at server" << InetAddr.toString() << "for ID =" << iID;
+
+    if ( iID != PROTMESSID_CLM_CLIENT_ID )
+    {
+        emit CLTcpSupportedReceived ( InetAddr, iID ); // pass to connect dialog
+        return;
+    }
+
+    // if client ID already received, make TCP connection to server
+    bTcpSupported = true;
+
+    if ( iClientID != INVALID_INDEX )
+    {
+        // *** Make TCP connection
+        qDebug() << Q_FUNC_INFO << "need to make TCP connection for" << iClientID;
+        Q_ASSERT ( InetAddr == Channel.GetAddress() );
+        ConnLessProtocol.CreateCLClientIDMes ( InetAddr, iClientID, PROTO_TCP_LONG ); // create persistent TCP connection
+    }
+}
+
+void CClient::OnCLConnClientsListMesReceived ( CHostAddress InetAddr, CVector<CChannelInfo> vecChanInfo, CTcpConnection* pTcpConnection )
+{
+    // test if we are receiving for the connect dialog or a connected session
+    if ( pTcpConnection && pTcpConnection->IsSession() )
+    {
+        qDebug() << "- sending client list to client dialog";
+        OnConClientListMesReceived ( vecChanInfo ); // connected session
+    }
+    else
+    {
+        qDebug() << "- sending client list to connect dialog";
+        emit CLConnClientsListMesReceived ( InetAddr, vecChanInfo ); // connect dialog
+    }
+}
+
 void CClient::Start()
 {
     // init object
     Init();
 
+    // clear TCP info
+    iClientID     = INVALID_INDEX;
+    bTcpSupported = false;
+
     // initialise client channels
     ClearClientChannels();
 
@@ -1052,6 +1175,14 @@ void CClient::Stop()
     // stop audio interface
     Sound.Stop();
 
+    // close any session TCP connection
+    CTcpConnection* pTcpConnection = Channel.GetTcpConnection();
+    if ( pTcpConnection )
+    {
+        Channel.SetTcpConnection ( nullptr );
+        pTcpConnection->disconnectFromHost();
+    }
+
     // disable channel
     Channel.SetEnable ( false );
 

src/client.h

@@ -302,9 +302,15 @@ class CClient : public QObject
 
     void CreateCLServerListReqVerAndOSMes ( const CHostAddress& InetAddr ) { ConnLessProtocol.CreateCLReqVersionAndOSMes ( InetAddr ); }
 
-    void CreateCLServerListReqConnClientsListMes ( const CHostAddress& InetAddr ) { ConnLessProtocol.CreateCLReqConnClientsListMes ( InetAddr ); }
+    void CreateCLServerListReqConnClientsListMes ( const CHostAddress& InetAddr, enum EProtoMode eProtoMode )
+    {
+        ConnLessProtocol.CreateCLReqConnClientsListMes ( InetAddr, eProtoMode );
+    }
 
-    void CreateCLReqServerListMes ( const CHostAddress& InetAddr ) { ConnLessProtocol.CreateCLReqServerListMes ( InetAddr ); }
+    void CreateCLReqServerListMes ( const CHostAddress& InetAddr, enum EProtoMode eProtoMode )
+    {
+        ConnLessProtocol.CreateCLReqServerListMes ( InetAddr, eProtoMode );
+    }
 
     int EstimatedOverallDelay ( const int iPingTimeMs );
 
@@ -448,12 +454,16 @@ class CClient : public QObject
     int    maxGainOrPanId;
     int    iCurPingTime;
 
+    // for TCP protocol support
+    bool bTcpSupported;
+    int  iClientID;
+
 protected slots:
     void OnHandledSignal ( int sigNum );
     void OnSendProtMessage ( CVector<uint8_t> vecMessage );
     void OnInvalidPacketReceived ( CHostAddress RecHostAddr );
 
-    void OnDetectedCLMessage ( CVector<uint8_t> vecbyMesBodyData, int iRecID, CHostAddress RecHostAddr );
+    void OnDetectedCLMessage ( CVector<uint8_t> vecbyMesBodyData, int iRecID, CHostAddress RecHostAddr, CTcpConnection* pTcpConnection );
 
     void OnReqJittBufSize() { CreateServerJitterBufferMessage(); }
     void OnJittBufSizeChanged ( int iNewJitBufSize );
@@ -467,8 +477,9 @@ protected slots:
         }
     }
     void OnCLPingReceived ( CHostAddress InetAddr, int iMs );
+    void OnCLTcpSupportedReceived ( CHostAddress InetAddr, int iID );
 
-    void OnSendCLProtMessage ( CHostAddress InetAddr, CVector<uint8_t> vecMessage );
+    void OnSendCLProtMessage ( CHostAddress InetAddr, CVector<uint8_t> vecMessage, CTcpConnection* pTcpConnection, enum EProtoMode eProtoMode );
 
     void OnCLPingWithNumClientsReceived ( CHostAddress InetAddr, int iMs, int iNumClients );
 
@@ -483,6 +494,13 @@ protected slots:
     void OnMuteStateHasChangedReceived ( int iServerChanID, bool bIsMuted );
     void OnCLChannelLevelListReceived ( CHostAddress InetAddr, CVector<uint16_t> vecLevelList );
     void OnConClientListMesReceived ( CVector<CChannelInfo> vecChanInfo );
+    void OnCLConnClientsListMesReceived ( CHostAddress InetAddr, CVector<CChannelInfo> vecChanInfo, CTcpConnection* pTcpConnection );
+
+public slots:
+    void OnCLSendEmptyMes ( CHostAddress InetAddr, CTcpConnection* pTcpConnection )
+    {
+        ConnLessProtocol.CreateCLEmptyMes ( InetAddr, pTcpConnection );
+    }
 
 signals:
     void ConClientListMesReceived ( CVector<CChannelInfo> vecChanInfo );
@@ -498,6 +516,8 @@ protected slots:
 
     void CLRedServerListReceived ( CHostAddress InetAddr, CVector<CServerInfo> vecServerInfo );
 
+    void CLTcpSupportedReceived ( CHostAddress InetAddr, int iID );
+
     void CLConnClientsListMesReceived ( CHostAddress InetAddr, CVector<CChannelInfo> vecChanInfo );
 
     void CLPingTimeWithNumClientsReceived ( CHostAddress InetAddr, int iPingTime, int iNumClients );

src/clientdlg.cpp

@@ -529,6 +529,8 @@ CClientDlg::CClientDlg ( CClient*         pNCliP,
 
     QObject::connect ( pClient, &CClient::CLRedServerListReceived, this, &CClientDlg::OnCLRedServerListReceived );
 
+    QObject::connect ( pClient, &CClient::CLTcpSupportedReceived, this, &CClientDlg::OnCLTcpSupportedReceived );
+
     QObject::connect ( pClient, &CClient::CLConnClientsListMesReceived, this, &CClientDlg::OnCLConnClientsListMesReceived );
 
     QObject::connect ( pClient, &CClient::CLPingTimeWithNumClientsReceived, this, &CClientDlg::OnCLPingTimeWithNumClientsReceived );