HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r76:630afd0dda2f

GRESB Read/Write ops are working but Read has a memory leak.

Jeandet Alexis -

r76:630afd0dda2f GRESB

parent child

Context file:

r76:630afd0dda2f

Collapse all files

spwplugin/GR-ESB/gr_esb_bridge.cpp +143 -65

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  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, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "gr_esb_bridge.h"
             #include "gr_esb_ui.h"
             #include <unistd.h>
             #include "spw.h"
             #include <socexplorerengine.h>
             GR_ESB_bridge::GR_ESB_bridge(socexplorerplugin *parent) :
                 abstractSpwBridge(parent)
             {
                 this->p_GUI = new GR_ESB_ui();
                 this->manager = new GR_ESB_Manager(parent,this);
                 connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(ipchanged(QString)),this,SLOT(setIP(QString)));
                 connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(vlinkchanged(QString)),this,SLOT(setVirtualLink(QString)));
                 connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(connectClicked()),this,SLOT(toggleBridgeConnection()));
                 this->manager->virtualLinkIndex = 0;
                 this->manager->start();
             }
             GR_ESB_bridge::~GR_ESB_bridge()
             {
                 this->manager->requestInterruption();
                 while(this->manager->isRunning());
             }
             void GR_ESB_bridge::toggleBridgeConnection()
             {
                 if(this->plugin->isConnected())
                 {
                     this->disconnectBridge();
                 }
                 else
                 {
                     this->connectBridge();
                 }
             }
             bool GR_ESB_bridge::connectBridge()
             {
                 if(this->manager->connectBridge())
                 {
                     ((GR_ESB_ui*)this->p_GUI)->lock(true);
                     emit setConnected(true);
                     return true;
                 }
                 return false;
             }
             bool GR_ESB_bridge::disconnectBridge()
             {
                 if(this->manager->disconnectBridge())
                 {
                     ((GR_ESB_ui*)this->p_GUI)->lock(false);
                     emit setConnected(false);
                     return true;
                 }
                 return false;
             }
             void GR_ESB_bridge::setIP(QString ip)
             {
                 this->manager->IP = ip;
             }
             void GR_ESB_bridge::setVirtualLink(QString vlink)
             {
-                vlink = vlink.section("Virtual link",0,0);
+                //vlink = vlink.section(,0,0);
+                vlink.remove("Virtual link");
                 bool success;
                 int vlinkTmp = vlink.toInt(&success);
                 if(success)
                 {
                     setVirtualLink(vlinkTmp);
                 }
             }
             void GR_ESB_bridge::setVirtualLink(qint32 vlink)
             {
                 if(vlink<6 && vlink>=0)
                 {
                     this->manager->virtualLinkIndex = vlink;
                 }
             }
             unsigned int GR_ESB_bridge::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char writeBuffer[RMAP_WRITE_PACKET_MIN_SZ((RMAP_MAX_XFER_SIZE*4))];
                 char *RMAPAckBuff;
                 int transactionID = 0;
                 int written=0;
                 SocExplorerEngine::message(this->plugin,"Enter Write function",2);
                 QProgressBar* progress=NULL;
                 SocExplorerAutoProgressBar autopb;
                 if(count>RMAP_MAX_XFER_SIZE)
                 {
                     progress= SocExplorerEngine::getProgressBar("Writing on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     autopb.setProgressBar(progress);
                 }
                 //Quite stupide loop, I guess that I always get the number of byte I asked for!
                 while(count>=RMAP_MAX_XFER_SIZE)
                 {
                     for(int i=0;i<(RMAP_MAX_XFER_SIZE);i++)
                     {
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+0] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written])&0xFF);
                     }
                     transactionID=manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
                     RMAP_build_tx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(written*4),
                                 RMAP_MAX_XFER_SIZE*4,
                                 writeBuffer);
                     manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(RMAP_MAX_XFER_SIZE*4));
-                    manager->getRMAPanswer(transactionID,&RMAPAckBuff);
+                    int len = manager->getRMAPanswer(transactionID,&RMAPAckBuff);
                     free(RMAPAckBuff);
                     written+=RMAP_MAX_XFER_SIZE;
                     count-=RMAP_MAX_XFER_SIZE;
                     progress->setValue(written);
                     qApp->processEvents();
                 }
                 if(count>0)
                 {
                     for(int i=0;i<((int)count);i++)
                     {
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+0] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written])&0xFF);
                     }
                     transactionID=manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
                     RMAP_build_tx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(written*4),
                                 count*4,
                                 writeBuffer);
                     manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(count*4));
-                    manager->getRMAPanswer(transactionID,&RMAPAckBuff);
+                    int len = manager->getRMAPanswer(transactionID,&RMAPAckBuff);
                     free(RMAPAckBuff);
                     written+=count;
                     if(progress!=NULL)
                     {
                         progress->setValue(written);
                         qApp->processEvents();
                     }
                 }
                 return written;
             }
             unsigned int GR_ESB_bridge::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char requestBuffer[RMAP_READ_HEADER_MIN_SZ];
                 char* RMAP_AnswerBuffer;
                 requestBuffer[0]=this->manager->linkNumber;//Link number
                 int transactionID = 0;
                 int read=0;
                 QProgressBar* progress=NULL;
                 SocExplorerAutoProgressBar autopb;
                 if(count>RMAP_MAX_XFER_SIZE)
                 {
                     progress= SocExplorerEngine::getProgressBar("Reading on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     autopb.setProgressBar(progress);
                 }
                 SocExplorerEngine::message(this->plugin,QString("Enter read function, count=%1, RMAP_MAX_XFER_SIZE=%2").arg(count).arg(RMAP_MAX_XFER_SIZE),2);
                 //Quite stupide loop, I guess that I always get the number of byte I asked for!
                 while((int)count>=(int)RMAP_MAX_XFER_SIZE)
                 {
                     transactionID = manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("New transactionID:%1").arg(transactionID),2);
                     RMAP_build_rx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(read*4),
                                 RMAP_MAX_XFER_SIZE*4,
                                 requestBuffer);
                     manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ);
                     int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
                     if(len==-1)
                     {
                         this->toggleBridgeConnection();
                         return 0;
                     }
                     for(int i=0;i<((len-13)/4);i++)
                     {
                         Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
                     }
                     free(RMAP_AnswerBuffer);
                     read+=RMAP_MAX_XFER_SIZE;
                     count-=RMAP_MAX_XFER_SIZE;
                     progress->setValue(read);
                     qApp->processEvents();
                 }
                 if((int)count>0)
                 {
                     transactionID = manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("New transactionID: %1").arg(transactionID),2);
                     SocExplorerEngine::message(this->plugin,QString("Building request with:"),2);
                     SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16),2);
                     SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4),2);
                     SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13),2);
                     RMAP_build_rx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(read*4),
                                 count*4,
                                 requestBuffer);
                     manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ);
                     int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
                     if(len==-1)
                     {
                         this->toggleBridgeConnection();
                         return 0;
                     }
                     for(int i=0;i<((len-13)/4);i++)
                     {
                         Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
                     }
                     free(RMAP_AnswerBuffer);
                     read+=count;
                     if(progress!=NULL)
                     {
                         progress->setValue(read);
                         qApp->processEvents();
                     }
                 }
                 return read;
             }
             int GR_ESB_bridge::pushRMAPPacket(char *packet, int size)
             {
                 return this->manager->sendPacket(packet,size);
             }
             GR_ESB_Manager::GR_ESB_Manager(socexplorerplugin *plugin, QObject *parent)
                 :abstractSpwManager(plugin, parent)
             {
-                this->Read_soc = new QTcpSocket(this);
+                //    this->Read_soc = new QTcpSocket(this);
-                this->Write_soc = new QTcpSocket(this);
+                //    this->Write_soc = new QTcpSocket(this);
                 this->sourceLogicalAddress=32;
                 this->destinationLogicalAddress=254;
                 this->destinationKey=2;
+                connect(&(this->Read_soc),SIGNAL(readyRead()),this,SLOT(readyRead()));
             }
             GR_ESB_Manager::~GR_ESB_Manager()
             {
             }
+            void GR_ESB_Manager::__processPacket(packetBuffer_t *packet)
+            {
+                if(packet->complete)
+                {
+                    if(packet->buffer[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
+                    {
+                        RMAP_Answer* RMapPacket;
+                        //SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
+                        //SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(packet->PacketLen),2);
+                        char* packetbuffer = (char*)malloc(packet->PacketLen);
+                        if(packetbuffer)
+                        {
+                            memcpy(packetbuffer,packet->buffer,packet->PacketLen);
+                            this->handleMutex->unlock();
+                            if(packet->PacketLen==8)
+                            {
+                                RMapPacket=new RMAP_Answer(RMAP_get_transactionID(packetbuffer),packetbuffer,packet->PacketLen);
+                            }
+                            else
+                            {
+                                RMapPacket=new RMAP_Answer(RMAP_get_transactionID(packetbuffer),packetbuffer,packet->PacketLen);
+                            }
+                            RMAP_AnswersMtx->lock();
+                            RMAP_Answers.append(RMapPacket);
+                            RMAP_AnswersMtx->unlock();
+                            RMAP_AnswersSem->release();
+                        }
+                    }
+                    else //any non-rmap packet will be pushed to the network
+                    {
+                        char* packetbuffer = (char*)malloc(packet->PacketLen);
+                        if(packetbuffer)
+                        {
+                            //memcpy(packetbuffer,packet->buffer,packet->PacketLen);
+                            //emit emitPacket(packetbuffer,packet->PacketLen);
+                            //SocExplorerEngine::message(this->plugin,"Got SPW packet",2);
+                        }
+                    }
+                }
+            }
+            QByteArray GR_ESB_Manager::__processData(const QByteArray &data, packetBuffer_t *buffer)
+            {
+                if(buffer->complete)
+                {
+                    if(Q_UNLIKELY(data.size()<=4))
+                        return data;
+                    buffer->PacketLen= ((int)data.at(3)& 0x0FF) + (((int)data.at(2)& 0x0FF)<<8) + (((int)data.at(1)& 0x0FF)<<16);
+                    if(buffer->PacketLen>(data.size()-4))
+                    {
+                        memcpy(buffer->buffer,data.data()+4,data.size()-4);
+                        buffer->complete=false;
+                        buffer->index=data.size()-4;
+                    }
+                    else
+                    {
+                        memcpy(buffer->buffer,data.data()+4,data.size()-4);
+                        buffer->PacketLen = data.size()-4;
+                        buffer->index=data.size()-4;
+                        buffer->complete=true;
+                        __processPacket(buffer);
+                        int len = buffer->PacketLen;
+                        buffer->PacketLen = 0;
+                        buffer->index=0;
+                        if((data.size()-4-len))
+                        {
+                           return __processData(data.right((data.size()-4-len)),buffer);
+                        }
+                    }
+                }
+                else
+                {
+                    if(buffer->PacketLen>(data.size()+buffer->index))
+                    {
+                        memcpy(buffer->buffer+buffer->index,data.data(),data.size());
+                        buffer->complete=false;
+                        buffer->index+=data.size();
+                    }
+                    else
+                    {
+                        memcpy(buffer->buffer+buffer->index,data.data(),buffer->PacketLen-buffer->index);
+                        buffer->complete=true;
+                        buffer->index+=data.size();
+                        __processPacket(buffer);
+                        int len = buffer->PacketLen;
+                        buffer->PacketLen = 0;
+                        buffer->index=0;
+                        if((data.size()-len))
+                        {
+                           return __processData(data.right((data.size()-len)),buffer);
+                        }
+                    }
+                }
+                return QByteArray();
+            }
             void GR_ESB_Manager::run()
             {
-                char buffer[(RMAP_MAX_XFER_SIZE*4)+50];
+                char bufferData[(RMAP_MAX_XFER_SIZE*4)+50];
-                SocExplorerEngine::message(this->plugin,"Starting GRESB pooling thread",1);
+                packetBuffer_t buffer={bufferData,0,0,true};
+                //SocExplorerEngine::message(this->plugin,"Starting GRESB pooling thread",1);
+                QByteArray data;
                 while (!this->isInterruptionRequested())
                 {
                     if(this->connected)
                     {
-                        handleMutex->lock();
+                        //SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",8);
-                        SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",5);
+                        if(!incomingPackets.isEmpty())
-                        if(Read_soc->waitForReadyRead(100))
                         {
-                            QByteArray data = Read_soc->readAll();
+                            incomingPacketsMutex.lock();
-                            int PacketLen= ((int)data.at(2)& 0x0FF) + (((int)data.at(3)& 0x0FF)<<8) + (((int)data.at(4)& 0x0FF)<<16);
+                            data.append(incomingPackets.dequeue());
-                            if(data[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
+                            this->incomingPacketsMutex.unlock();
+                            data = __processData(data,&buffer);
-                                RMAP_Answer* packet;
-                                SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
-                                SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(PacketLen),2);
-                                char* packetbuffer = (char*)malloc(PacketLen);
-                                memcpy(packetbuffer,data.data(),PacketLen);
-                                this->handleMutex->unlock();
-                                if(PacketLen==8)
-                                    packet=new RMAP_Answer(RMAP_get_transactionID(buffer),packetbuffer,PacketLen);
-                                else
-                                    packet=new RMAP_Answer(RMAP_get_transactionID(buffer+1),packetbuffer,PacketLen);
-                                RMAP_AnswersMtx->lock();
-                                RMAP_Answers.append(packet);
-                                RMAP_AnswersMtx->unlock();
-                                RMAP_AnswersSem->release();
-                            else //any non-rmap packet will be pushed to the network
-                                char* packetbuffer = (char*)malloc(PacketLen);
-                                memcpy(packetbuffer,data.data(),PacketLen);
-                                emit emitPacket(packetbuffer,PacketLen);
-                                this->handleMutex->unlock();
-                                SocExplorerEngine::message(this->plugin,"Got SPW packet",2);
-                        else
-                            handleMutex->unlock();
                         }
                     }
                     else
                     {
                         //do some sanity checks!
                         usleep(RMAPtimeout/2);
                     }
                     usleep(1000);
                 }
-                SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
+                //SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
             }
             bool GR_ESB_Manager::connectBridge()
             {
                 int timeout=60;
-                if(this->Read_soc->state()==QTcpSocket::UnconnectedState)
+                this->connected = false;
+                if(this->Read_soc.state()==QTcpSocket::UnconnectedState)
                 {
-                    this->Read_soc->connectToHost(IP,gresb_Conf[virtualLinkIndex].Receive_port);
+                    this->Read_soc.connectToHost(IP,gresb_Conf[virtualLinkIndex].Receive_port);
-                    this->Read_soc->waitForConnected(30000);
+                    this->Read_soc.waitForConnected(30000);
                 }
-                if(this->Write_soc->state()==QTcpSocket::UnconnectedState)
+                if(this->Write_soc.state()==QTcpSocket::UnconnectedState)
                 {
-                    this->Write_soc->connectToHost(IP,gresb_Conf[virtualLinkIndex].Transmit_port);
+                    this->Write_soc.connectToHost(IP,gresb_Conf[virtualLinkIndex].Transmit_port);
-                    this->Write_soc->waitForConnected(30000);
+                    this->Write_soc.waitForConnected(30000);
                 }
-                while((this->Read_soc->state()!=QTcpSocket::ConnectedState) && (this->Write_soc->state()!=QTcpSocket::ConnectedState))
+                while((this->Read_soc.state()!=QTcpSocket::ConnectedState) && (this->Write_soc.state()!=QTcpSocket::ConnectedState))
                 {
                     usleep(100000);
                     if(timeout--==0)return false;
                 }
+                this->connected = true;
                 return true;
             }
             bool GR_ESB_Manager::disconnectBridge()
             {
                 int timeout=60;
-                if(this->Read_soc->state()!=QTcpSocket::UnconnectedState)
+                if(this->Read_soc.state()!=QTcpSocket::UnconnectedState)
                 {
-                    this->Read_soc->disconnectFromHost();
+                    this->Read_soc.disconnectFromHost();
-                    this->Read_soc->waitForDisconnected(30000);
+                    this->Read_soc.waitForDisconnected(30000);
                 }
-                if(this->Write_soc->state()!=QTcpSocket::UnconnectedState)
+                if(this->Write_soc.state()!=QTcpSocket::UnconnectedState)
                 {
-                    this->Write_soc->disconnectFromHost();
+                    this->Write_soc.disconnectFromHost();
-                    this->Write_soc->waitForDisconnected(30000);
+                    this->Write_soc.waitForDisconnected(30000);
                 }
-                while((this->Read_soc->state()!=QTcpSocket::UnconnectedState) && (this->Write_soc->state()!=QTcpSocket::UnconnectedState))
+                while((this->Read_soc.state()!=QTcpSocket::UnconnectedState) && (this->Write_soc.state()!=QTcpSocket::UnconnectedState))
                 {
                     usleep(100000);
                     if(timeout--==0)return false;
                 }
                 return true;
             }
             bool GR_ESB_Manager::sendPacket(char *packet, int size)
             {
                 bool result = false;
                 char protocoleIdentifier;
                 SocExplorerEngine::message(this->plugin,"Sending SPW packet",2);
-                if(Q_UNLIKELY(this->Write_soc->state()!=QAbstractSocket::ConnectedState))
+                if(Q_UNLIKELY(this->Write_soc.state()!=QAbstractSocket::ConnectedState))
                 {
                     SocExplorerEngine::message(this->plugin,"Socket closed",2);
                     //TODO handle disconnection
                 }
                 char* SPWpacket = (char*)malloc(size+4);
                 if(SPWpacket!=NULL)
                 {
                     SPWpacket[0]=0; //Protocol = spw
                     memcpy(SPWpacket+4,packet,size);
                     SPWpacket[1]=(size>>16) & 0x0FF;
                     SPWpacket[2]=(size>>8) & 0x0FF;
                     SPWpacket[3]=size & 0x0FF;
                 }
                 this->handleMutex->lock();
-                result = ((size+4) == this->Write_soc->write(SPWpacket,size+4));
+                result = ((size+4) == this->Write_soc.write(SPWpacket,size+4));
+                this->Write_soc.flush();
                 this->handleMutex->unlock();
                 if (Q_UNLIKELY(!result))
                 {
                     SocExplorerEngine::message(this->plugin,"ERR sending the READ command ",2);
                     return false;
                 }
                 else
                 {
                     emit bytesTransmittedToSpw( size-1 ); // -1 is for removing the first bytes added to the packet to route to the right link
                     // read the protocole identifier
                     protocoleIdentifier = packet[2];
                     if (protocoleIdentifier == SPW_PROTO_ID_CCSDS)
-                            emit ccsdsPacketTransmittedToSpw();
+                        emit ccsdsPacketTransmittedToSpw();
                     SocExplorerEngine::message(this->plugin,"Packet sent",2);
                 }
                 return true;
             }
+            void GR_ESB_Manager::readyRead()
+            {
+                incomingPacketsMutex.lock();
+                incomingPackets.append(Read_soc.readAll());
+                incomingPacketsMutex.unlock();
+            }

spwplugin/GR-ESB/gr_esb_bridge.h +25 -8

             #ifndef GR_ESB_BRIDGE_H
             #define GR_ESB_BRIDGE_H
             #include "abstractspwbridge.h"
             #include <QTcpSocket>
             #include <QThread>
             #include <QMutex>
             #include <QSemaphore>
+            #include <QQueue>
             struct gresb_Conf_str
             {
                 qint32 Transmit_port;
                 qint32 Receive_port;
             };
             const struct gresb_Conf_str gresb_Conf[]=
             {
-                {3000,3001},  //Virtual link 0
+            {3000,3001},  //Virtual link 0
-                {3002,3003},  //Virtual link 1
+            {3002,3003},  //Virtual link 1
-                {3004,3005},  //Virtual link 2
+            {3004,3005},  //Virtual link 2
-                {3006,3007},  //Virtual link 3
+            {3006,3007},  //Virtual link 3
-                {3008,3009},  //Virtual link 4
+            {3008,3009},  //Virtual link 4
-                {3010,3011}   //Virtual link 5
+            {3010,3011}   //Virtual link 5
             };
             class GR_ESB_Manager: public abstractSpwManager
             {
                 Q_OBJECT
+                typedef struct packetBuffer_t
+                {
+                    char* buffer;
+                    int PacketLen;
+                    int index;
+                    bool complete;
+                }packetBuffer_t;
             public:
                 explicit GR_ESB_Manager(socexplorerplugin *plugin = 0,QObject* parent=0);
                 ~GR_ESB_Manager();
                 void run();
                 bool connectBridge();
                 bool disconnectBridge();
                 bool sendPacket(char* packet,int size);
             signals:
                 void emitPacket(char* packet,int size);
             private:
                 void pushRmapPacket(char* packet,int len);
                 char* SPWPacketBuff;
+                void __processPacket(packetBuffer_t *packet);
+                QByteArray __processData(const QByteArray &data, packetBuffer_t* buffer);
+            private slots:
+                void readyRead();
             public:
-                QTcpSocket* Read_soc;
+                QTcpSocket Read_soc;
-                QTcpSocket* Write_soc;
+                QTcpSocket Write_soc;
+                QMutex incomingPacketsMutex;
+                QQueue<QByteArray> incomingPackets;
                 QString IP;
                 int virtualLinkIndex;
             };
             class GR_ESB_bridge : public abstractSpwBridge
             {
                 Q_OBJECT
             public:
                 explicit GR_ESB_bridge(socexplorerplugin *parent = 0);
                 ~GR_ESB_bridge();
             signals:
             public slots:
                 void toggleBridgeConnection();
                 bool connectBridge();
                 bool disconnectBridge();
                 void setIP(QString ip);
                 void setVirtualLink(QString vlink);
                 void setVirtualLink(qint32 vlink);
                 unsigned int Write(unsigned int *Value,unsigned int count, unsigned int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 int pushRMAPPacket(char* packet,int size);
                 void packetReceived();
             private:
                 GR_ESB_Manager* manager;
             };
             #endif // GR_ESB_BRIDGE_H

spwplugin/abstractspwbridge.cpp +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  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, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "abstractspwbridge.h"
             #include <QTime>
             #include <socexplorerengine.h>
             abstractSpwBridge::abstractSpwBridge(socexplorerplugin *parent)
                 :QObject((QObject*)parent)
             {
                 this->plugin = parent;
                 this->p_GUI=NULL;
             }
             abstractSpwBridge::~abstractSpwBridge()
             {
             //        delete this->p_GUI;
             }
             QWidget *abstractSpwBridge::getGUI()
             {
                 return this->p_GUI;
             }
             bool abstractSpwBridge::connectBridge()
             {
                 return false;
             }
             bool abstractSpwBridge::disconnectBridge()
             {
                 return false;
             }
             abstractSpwManager::abstractSpwManager(socexplorerplugin *plugin, QObject *parent)
                 :QThread((QObject*)parent)
             {
                 this->RMAPtimeout = 2000;
                 this->handleMutex = new QMutex(QMutex::NonRecursive);
                 this->RMAP_AnswersSem = new QSemaphore(0);
                 this->RMAP_AnswersMtx=new QMutex(QMutex::Recursive);
                 this->RMAP_pending_transaction_IDsMtx=new QMutex(QMutex::Recursive);
                 this->plugin = plugin;
                 connected = false;
             }
             abstractSpwManager::~abstractSpwManager()
             {
                 this->terminate();
                 while (!this->isFinished())
                 {
                     this->usleep(1000);
                 }
             }
             int abstractSpwManager::getRMAPtransactionID()
             {
                 this->RMAP_pending_transaction_IDsMtx->lock();
                 int  ID=0;
                 bool found=true;
                 while(ID<511)
                 {
                     for(int i=0;i<RMAP_pending_transaction_IDs.count();i++)
                     {
                         if(RMAP_pending_transaction_IDs[i]==ID)found=false;
                     }
                     if(found==true)break;
                     ID++;
                     found = true;
                 }
                 if(found)
                 {
                     RMAP_pending_transaction_IDs.append(ID);
                 }
                 this->RMAP_pending_transaction_IDsMtx->unlock();
                 return ID;
             }
             int abstractSpwManager::getRMAPanswer(int transactionID, char **buffer)
             {
                 QTime timeout;
                 *buffer=NULL;
                 int count=0;
                 SocExplorerEngine::message(this->plugin,"Looking for RMAP answer",2);
+                qApp->processEvents();
                 timeout.start();
                 while (*buffer==NULL)
                 {
                     this->RMAP_AnswersMtx->lock();
                     SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_Answers stack",2);
                     SocExplorerEngine::message(this->plugin,QString("%1 packet(s) available in RMAP_Answers stack").arg(RMAP_Answers.count()),2);
                     for(int i=0;i<RMAP_Answers.count();i++)
                     {
                         SocExplorerEngine::message(this->plugin,QString("Packet %1 ID=%2").arg(i).arg(RMAP_Answers[i]->transactionID),2);
                         if(RMAP_Answers[i]->transactionID==transactionID)
                         {
                             this->RMAP_pending_transaction_IDsMtx->lock();
                             SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_pending_transaction_ID stack",2);
                             for(int j=0;j<RMAP_pending_transaction_IDs.count();j++)
                             {
                                 if(RMAP_pending_transaction_IDs[j]==transactionID)
                                 {
                                     RMAP_pending_transaction_IDs.removeAt(j);
                                 }
                             }
                             this->RMAP_pending_transaction_IDsMtx->unlock();
                             *buffer = RMAP_Answers[i]->data;
                             count = RMAP_Answers[i]->len;
                             RMAP_Answer* tmp=RMAP_Answers[i];
                             RMAP_Answers.removeAt(i);
                             delete tmp;
                         }
                     }
                     this->RMAP_AnswersMtx->unlock();
                     //if no answer found in the stack wait until a new packet is pushed
                     SocExplorerEngine::message(this->plugin,"waiting until a new packet is pushed",2);
                     if(*buffer==NULL)
                     {
                         while (0==this->RMAP_AnswersSem->available())
                         {
                             SocExplorerEngine::message(this->plugin,QString("this->RMAP_AnswersSem->available() = %1").arg(this->RMAP_AnswersSem->available()),2);
                             if(timeout.elapsed()>=RMAPtimeout)
                             {
                                 SocExplorerEngine::message(this->plugin,"Timeout reached giving up!",2);
                                 return -1;
                             }
                             usleep(1000);
+                            qApp->processEvents();
                         }
                         this->RMAP_AnswersSem->acquire();
                     }
                 }
                 return count;
             }
             int abstractSpwManager::getLinkNumber()
             {
                 return this->linkNumber;
             }
             void abstractSpwManager::pushRmapPacket(char *packet, int len)
             {
                 char* packetbuffer = (char*)malloc(len);
                 memcpy(packetbuffer,packet,len);
                 RMAP_Answer* RMPAPpacket=new RMAP_Answer(RMAP_get_transactionID(packetbuffer+1),packetbuffer,len);
                 RMAP_AnswersMtx->lock();
                 RMAP_Answers.append(RMPAPpacket);
                 RMAP_AnswersMtx->unlock();
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages