diff --git a/slsReceiverSoftware/include/UDPStandardImplementation.h b/slsReceiverSoftware/include/UDPStandardImplementation.h index 482ac4ce4..c1023a996 100644 --- a/slsReceiverSoftware/include/UDPStandardImplementation.h +++ b/slsReceiverSoftware/include/UDPStandardImplementation.h @@ -416,6 +416,24 @@ private: */ int prepareAndListenBuffer(int ithread, int cSize, char* temp); + /** + * Called by startListening + * Creates the packets + * @param ithread listening thread index + * @return the number of bytes actually received + */ + int prepareAndListenBufferDeactivated(int ithread); + + + /** + * Called by startListening + * Listens to each packet and copies only complete frames + * until all receiver or shutdownUDPsocket called by client + * @param ithread listening thread index + * @return the number of bytes copied to buffer + */ + int prepareAndListenBufferCompleteFrames(int ithread); + /** * Called by startListening * Its called for the first packet of a scan or acquistion @@ -478,14 +496,13 @@ private: void handleWithoutDataCompression(int ithread, char* wbuffer,uint32_t npackets); /** - * Called by processWritingBuffer for jungfrau - * writes to dummy file, doesnt need to read packet numbers + * Called by startWriting for jungfrau and eiger + * writes complete frames to file * Copies data for gui display and frees addresses popped from FIFOs * @param ithread writing thread index * @param wbuffer writing buffer popped out from FIFO - * @param npackets number of packets */ - void handleWithoutMissingPackets(int ithread, char* wbuffer,uint32_t npackets); + void handleCompleteFramesOnly(int ithread, char* wbuffer); /** * Calle by handleWithoutDataCompression @@ -540,9 +557,10 @@ private: * @param framenumber reference to the frame number * @param packetnumber reference to the packet number * @param subframenumber reference to the subframe number + * @oaram bunchid reference to the bunch id * @return OK or FAIL */ - int getFrameandPacketNumber(int ithread, char* wbuffer, uint64_t &framenumber, uint32_t &packetnumber, uint32_t &subframenumber); + int getFrameandPacketNumber(int ithread, char* wbuffer, uint64_t &framenumber, uint32_t &packetnumber, uint32_t &subframenumber, uint64_t &bunchid); /** * Find offset upto this frame number and write it to file @@ -593,6 +611,9 @@ private: /** Footer offset from start of Packet*/ int footerOffset; + /** variable to exclude missing packet */ + bool excludeMissingPackets; + //***File parameters*** #ifdef MYROOT1 @@ -611,15 +632,17 @@ private: /** Maximum Frames Per File **/ uint64_t maxFramesPerFile; + const static int progressFrequency = 10; /** If file created successfully for all Writer Threads */ bool fileCreateSuccess; + /** File header */ const static unsigned int FILE_HEADER_SIZE = 500; - char fileHeader[MAX_NUMBER_OF_WRITER_THREADS][FILE_HEADER_SIZE]; - + /** File Descriptor */ + FILE *sfilefd[MAX_NUMBER_OF_WRITER_THREADS]; //***acquisition indices/count parameters*** @@ -640,9 +663,19 @@ private: /** Previous Frame number from last check to calculate loss */ int64_t frameNumberInPreviousCheck[MAX_NUMBER_OF_WRITER_THREADS]; + /** total packet count from last check */ int64_t totalWritingPacketCountFromLastCheck[MAX_NUMBER_OF_WRITER_THREADS]; + /** Pckets currently in current file, starts new file when it reaches max */ + int64_t lastFrameNumberInFile[MAX_NUMBER_OF_WRITER_THREADS]; + + /** packets in current file */ + uint64_t totalPacketsInFile[MAX_NUMBER_OF_WRITER_THREADS]; + + /**Total packet count written by each writing thread */ + uint64_t totalWritingPacketCount[MAX_NUMBER_OF_LISTENING_THREADS]; + /* Acquisition started */ bool acqStarted; @@ -656,14 +689,7 @@ private: /** Total packet Count ignored by listening threads */ int totalIgnoredPacketCount[MAX_NUMBER_OF_LISTENING_THREADS]; - /** Pckets currently in current file, starts new file when it reaches max */ - int64_t lastFrameNumberInFile[MAX_NUMBER_OF_WRITER_THREADS]; - /** packets in current file */ - uint64_t totalPacketsInFile[MAX_NUMBER_OF_WRITER_THREADS]; - - /**Total packet count written by each writing thread */ - uint64_t totalWritingPacketCount[MAX_NUMBER_OF_LISTENING_THREADS]; @@ -684,9 +710,6 @@ private: /** UDP Sockets - Detector to Receiver */ genericSocket* udpSocket[MAX_NUMBER_OF_LISTENING_THREADS]; - /** File Descriptor */ - FILE *sfilefd[MAX_NUMBER_OF_WRITER_THREADS]; - /** Number of Jobs Per Buffer */ int numberofJobsPerBuffer; @@ -696,9 +719,6 @@ private: /** fifo buffer header size */ uint32_t fifoBufferHeaderSize; - /** Missing Packet */ - int missingPacketinFile; - /** Dummy Packet identifier value */ const static uint32_t dummyPacketValue = 0xFFFFFFFF; @@ -790,16 +810,6 @@ private: bool killAllWritingThreads; - //***deactivated parameters*** - uint64_t deactivated_framenumber[MAX_NUMBER_OF_LISTENING_THREADS]; - uint32_t deactivated_packetnumber[MAX_NUMBER_OF_LISTENING_THREADS]; - - //***deactivated parameters*** - uint64_t deactivatedFrameNumber[MAX_NUMBER_OF_LISTENING_THREADS]; - int deactivatedFrameIncrement; - - - //***filter parameters*** /** Common Mode Subtraction Enable FIXME: Always false, only moench uses, Ask Anna */ bool commonModeSubtractionEnable; diff --git a/slsReceiverSoftware/include/genericSocket.h b/slsReceiverSoftware/include/genericSocket.h index 3f8046bd7..1e4f2b32f 100644 --- a/slsReceiverSoftware/include/genericSocket.h +++ b/slsReceiverSoftware/include/genericSocket.h @@ -632,7 +632,13 @@ enum communicationProtocol{ else{ //normal nsending=packet_size; - nsent = recvfrom(socketDescriptor,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length); + while(1){ + nsent = recvfrom(socketDescriptor,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length); + if(nsent<=0 || nsent == packet_size) + break; + if(nsent != packet_size && nsent != header_packet_size) + cprintf(RED,"Incomplete Packet size %d\n",nsent); + } //nsent = 1040; total_sent+=nsent; } diff --git a/slsReceiverSoftware/include/receiver_defs.h b/slsReceiverSoftware/include/receiver_defs.h index 77a3623d2..ec848bf4f 100755 --- a/slsReceiverSoftware/include/receiver_defs.h +++ b/slsReceiverSoftware/include/receiver_defs.h @@ -56,6 +56,10 @@ typedef struct { #define HEADER_SIZE_NUM_TOT_PACKETS 4 #define HEADER_SIZE_NUM_FRAMES 2 #define HEADER_SIZE_NUM_PACKETS 1 +#define ALL_MASK_32 0xFFFFFFFF + +#define FILE_FRAME_HEADER_LENGTH 16 +#define FILE_HEADER_BUNCHID_OFFSET 8 //all max frames defined in sls_receiver_defs.h. 20000 gotthard, 100000 for short gotthard, 1000 for moench, eiger 20000 @@ -129,8 +133,6 @@ typedef struct { -#define JFRAU_FILE_FRAME_HEADER_LENGTH 16 -#define JFRAU_FILE_HEADER_BUNCHID_OFFSET 8 #define JFRAU_FIFO_SIZE 2500 //cannot be less than max jobs per thread = 1000 #define JFRAU_PACKETS_PER_FRAME 128 #define JFRAU_HEADER_LENGTH 22 @@ -172,7 +174,6 @@ typedef struct { #define EIGER_MAX_PORTS 2 #define EIGER_HEADER_PACKET_LENGTH 48 - #define EIGER_FIFO_SIZE 100 /*#define EIGER_ALIGNED_FRAME_SIZE 65536*/ #define EIGER_ONE_GIGA_CONSTANT 16 diff --git a/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h b/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h index b16fab75f..0c5d5655e 100644 --- a/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h +++ b/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h @@ -332,7 +332,7 @@ private: protected: /** Socket */ - MySocketTCP* socket; + MySocketTCP* mySock; }; diff --git a/slsReceiverSoftware/src/UDPBaseImplementation.cpp b/slsReceiverSoftware/src/UDPBaseImplementation.cpp index 099a74f2a..8f57fba78 100644 --- a/slsReceiverSoftware/src/UDPBaseImplementation.cpp +++ b/slsReceiverSoftware/src/UDPBaseImplementation.cpp @@ -98,7 +98,7 @@ char *UDPBaseImplementation::getDetectorHostname() const{ if(!strlen(detHostname)) return NULL; - char* output = new char[MAX_STR_LENGTH]; + char* output = new char[MAX_STR_LENGTH](); strcpy(output,detHostname); //freed by calling function return output; @@ -113,7 +113,7 @@ char *UDPBaseImplementation::getFileName() const{ if(!strlen(fileName)) return NULL; - char* output = new char[MAX_STR_LENGTH]; + char* output = new char[MAX_STR_LENGTH](); strcpy(output,fileName); //freed by calling function return output; @@ -126,7 +126,7 @@ char *UDPBaseImplementation::getFilePath() const{ if(!strlen(filePath)) return NULL; - char* output = new char[MAX_STR_LENGTH]; + char* output = new char[MAX_STR_LENGTH](); strcpy(output,filePath); //freed by calling function return output; @@ -166,7 +166,7 @@ uint32_t UDPBaseImplementation::getUDPPortNumber2() const{ FILE_LOG(logDEBUG) << char *UDPBaseImplementation::getEthernetInterface() const{ FILE_LOG(logDEBUG) << __AT__ << " starting"; - char* output = new char[MAX_STR_LENGTH]; + char* output = new char[MAX_STR_LENGTH](); strcpy(output,eth); //freed by calling function return output; diff --git a/slsReceiverSoftware/src/UDPStandardImplementation.cpp b/slsReceiverSoftware/src/UDPStandardImplementation.cpp index 31e10a37a..f92adfb6f 100644 --- a/slsReceiverSoftware/src/UDPStandardImplementation.cpp +++ b/slsReceiverSoftware/src/UDPStandardImplementation.cpp @@ -138,6 +138,7 @@ void UDPStandardImplementation::initializeMembers(){ frameIndexOffset = 0; packetIndexMask = 0; footerOffset = 0; + excludeMissingPackets = false; //***file parameters*** #ifdef MYROOT1 @@ -148,6 +149,7 @@ void UDPStandardImplementation::initializeMembers(){ #endif for(int i=0; i(fifoSize); //allocate memory - mem0[i] = (char*)malloc((bufferSize * numberofJobsPerBuffer + fifoBufferHeaderSize) * fifoSize); + mem0[i] = (char*)calloc((bufferSize * numberofJobsPerBuffer + fifoBufferHeaderSize) * fifoSize,sizeof(char)); if (mem0[i] == NULL){ cprintf(BG_RED,"Error: Could not allocate memory for listening \n"); return FAIL; @@ -655,7 +651,7 @@ int UDPStandardImplementation::setDynamicRange(const uint32_t i){ //set parameters depending on new dynamic range. packetsPerFrame = (tengigaEnable ? EIGER_TEN_GIGA_CONSTANT : EIGER_ONE_GIGA_CONSTANT) * dynamicRange; - bufferSize = onePacketSize * packetsPerFrame; + bufferSize = oneDataSize * packetsPerFrame; for(int i=0; i DO_NOTHING)){ + updateFileHeader(ithread); + fseek(sfilefd[ithread],0,0); + fwrite((void*)fileHeader[ithread], 1, FILE_HEADER_SIZE, sfilefd[ithread]); + } + fflush(sfilefd[ithread]); fclose(sfilefd[ithread]); sfilefd[ithread] = 0; } @@ -1632,25 +1632,30 @@ int UDPStandardImplementation::createNewFile(int ithread){ //Print packet loss and filenames if(totalWritingPacketCount[ithread]){ if(numberofWriterThreads>1){ - cprintf(BLUE,"\nThread:%d File:%s" - "\nLost:%lld" - "\tPackets:%lld" + cprintf(BLUE,"File:%s" + "\nThread:%d" + "\tLost:%lld" + "\t\tPackets:%lld" "\tFrame#:%lld" "\tPFrame#:%lld\n", - ithread,completeFileName[ithread], - (long long int)(((currentFrameNumber[ithread]-frameNumberInPreviousFile[ithread])*packetsPerFrame) - totalPacketsInFile[ithread]), + completeFileName[ithread],ithread, + ((frameNumberInPreviousFile[ithread]+1+maxFramesPerFile)>numberOfFrames) + ?(long long int)((numberOfFrames-(frameNumberInPreviousFile[ithread]+1))*packetsPerFrame - totalPacketsInFile[ithread]) + :(long long int)((frameNumberInPreviousFile[ithread]+maxFramesPerFile - frameNumberInPreviousFile[ithread])*packetsPerFrame - totalPacketsInFile[ithread]), (long long int)totalPacketsInFile[ithread], (long long int)currentFrameNumber[ithread], (long long int)frameNumberInPreviousFile[ithread] ); }else{ - cprintf(BLUE,"\nFile:%s" + cprintf(BLUE,"File:%s" "\nLost:%lld" - "\tPackets:%lld" + "\t\tPackets:%lld" "\tFrame#:%lld" "\tPFrame#:%lld\n", completeFileName[ithread], - (long long int)(((currentFrameNumber[ithread]-frameNumberInPreviousFile[ithread])*packetsPerFrame) - totalPacketsInFile[ithread]), + ((frameNumberInPreviousFile[ithread]+1+maxFramesPerFile)>numberOfFrames) + ?(long long int)(numberOfFrames-(frameNumberInPreviousFile[ithread]+1)) + :(long long int)(frameNumberInPreviousFile[ithread]+maxFramesPerFile - frameNumberInPreviousFile[ithread]), (long long int)totalPacketsInFile[ithread], (long long int)currentFrameNumber[ithread], (long long int)frameNumberInPreviousFile[ithread] @@ -1776,7 +1781,7 @@ void UDPStandardImplementation::startDataCallback(){ while(true){ int oneframesize = oneDataSize * packetsPerFrame; - char* buffer = new char[packetsPerFrame*oneDataSize]; + char* buffer = new char[packetsPerFrame*oneDataSize](); memset(buffer,0xFF,oneframesize); int size = 0; int offset = 0; @@ -1784,6 +1789,7 @@ void UDPStandardImplementation::startDataCallback(){ uint64_t fnum = 0; uint32_t pnum = 0; uint32_t snum = 0; + uint64_t bid = 0; bool randomSendNow = true; bool newFrame = false; @@ -1815,10 +1821,10 @@ void UDPStandardImplementation::startDataCallback(){ if(guiNumPackets[ithread] == dummyPacketValue){ //sending previous half frames if any - if((myDetectorType != JUNGFRAU) && newFrame){ + if(!excludeMissingPackets && newFrame){ //send header //update frame details - frameIndex = fnum;if(frameIndex==-1) cprintf(RED,"frameindex = -1, 111\n"); + frameIndex = fnum; acquisitionIndex = fnum - startAcquisitionIndex; if(dynamicRange == 32) subframeIndex = snum; int len = sprintf(buf,jsonFmt,type,shape, acquisitionIndex, frameIndex, subframeIndex,completeFileName[ithread]); @@ -1867,16 +1873,16 @@ void UDPStandardImplementation::startDataCallback(){ } } - if(myDetectorType == JUNGFRAU){ + if(excludeMissingPackets){ //send header //update frame details - frameIndex = (*((uint32_t*)(latestData[ithread]))) - startFrameIndex; - acquisitionIndex = (*((uint32_t*)(latestData[ithread]))) - startAcquisitionIndex; + frameIndex = (*((uint64_t*)(latestData[ithread]))) - startFrameIndex; + acquisitionIndex = (*((uint64_t*)(latestData[ithread]))) - startAcquisitionIndex; subframeIndex = -1; int len = sprintf(buf,jsonFmt,type,shape, acquisitionIndex, frameIndex, subframeIndex,completeFileName[ithread]); zmq_send(zmqsocket, buf,len, ZMQ_SNDMORE); //send data - zmq_send(zmqsocket, latestData[ithread]+JFRAU_FILE_FRAME_HEADER_LENGTH, oneframesize, 0); + zmq_send(zmqsocket, latestData[ithread]+FILE_FRAME_HEADER_LENGTH, bufferSize, 0); //start clock after sending if(!frameToGuiFrequency){ randomSendNow = false; @@ -1885,7 +1891,7 @@ void UDPStandardImplementation::startDataCallback(){ } - //eiger + //moench, jctb else{ size = guiNumPackets[ithread]*onePacketSize; @@ -1896,7 +1902,7 @@ void UDPStandardImplementation::startDataCallback(){ while(offset < size){ //until getting frame number is not error - while((size>0) && (getFrameandPacketNumber(ithread, latestData[ithread]+offset, fnum, pnum,snum)==FAIL)){ + while((size>0) && (getFrameandPacketNumber(ithread, latestData[ithread]+offset, fnum, pnum,snum,bid)==FAIL)){ offset+= onePacketSize; } //if(!ithread) cout<< ithread <<" fnum:"<< fnum<<" pnum:"<pop(buffer[ithread]); -#ifdef EVERYFIFODEBUG - if(fifoFree[ithread]->getSemValue()<100) - cprintf(BLUE,"FifoFree[%d]: value:%d, pop 0x%x\n",ithread,fifoFree[ithread]->getSemValue(),(void*)(buffer[ithread])); -#endif -#ifdef CFIFODEBUG - if(ithread == 0) - cprintf(CYAN,"Listening_Thread %d :Listener popped from fifofree %p\n", ithread, (void*)(buffer[ithread])); - else - cprintf(YELLOW,"Listening_Thread %d :Listener popped from fifofree %p\n", ithread, (void*)(buffer[ithread])); -#endif - - //udpsocket doesnt exist if(activated && !udpSocket[ithread]){ FILE_LOG(logERROR) << "Listening_Thread " << ithread << ": UDP Socket not created or shut down earlier"; @@ -2070,44 +2064,27 @@ void UDPStandardImplementation::startListening(){ continue; } - rc = prepareAndListenBuffer(ithread, carryonBufferSize, tempBuffer); - carryonBufferSize = 0; + if(!activated) //eiger not activated modules + rc = prepareAndListenBufferDeactivated(ithread); + else if(excludeMissingPackets) //eiger and jungfrau + rc = prepareAndListenBufferCompleteFrames(ithread); + else{ + rc = prepareAndListenBuffer(ithread, carryonBufferSize, tempBuffer); //others + carryonBufferSize = 0; + } - //start indices for each start of scan/acquisition - if((!measurementStarted[ithread]) && (rc > 0)) - startFrameIndices(ithread); //problem in receiving or end of acquisition if (status == TRANSMITTING||(rc == 0 && activated == 0)){ stopListening(ithread,rc); continue; } - //write packet count to buffer - if(myDetectorType == JUNGFRAU) - (*((uint32_t*)(buffer[ithread]))) = (rc/oneDataSize); - else - (*((uint32_t*)(buffer[ithread]))) = (rc/onePacketSize); - if(dataCompressionEnable) (*((uint32_t*)(buffer[ithread]))) = processListeningBuffer(ithread, carryonBufferSize, tempBuffer, rc); - //push buffer to FIFO while(!fifo[ithread]->push(buffer[ithread])); -#ifdef EVERYFIFODEBUG - if(fifo[ithread]->getSemValue()>(fifoSize-100)) - cprintf(MAGENTA,"Fifo[%d]: value:%d, push 0x%x\n",ithread,fifo[ithread]->getSemValue(),(void*)(buffer[ithread])); -#endif -#ifdef CFIFODEBUG - if(ithread == 0) - cprintf(CYAN,"Listening_Thread %d: Listener pushed into fifo %p\n",ithread, (void*)(buffer[ithread])); - else - cprintf(YELLOW,"Listening_Thread %d: Listener pushed into fifo %p\n",ithread, (void*)(buffer[ithread])); - -#endif - - }/*--end of loop for each buffer (inner loop)*/ //end of acquisition, wait for next acquisition/change of parameters @@ -2134,173 +2111,22 @@ int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int cSize, ch int receivedSize = 0; //carry over from previous buffer - if(cSize) memcpy(buffer[ithread] + fifoBufferHeaderSize, temp, cSize); + if(cSize) + memcpy(buffer[ithread] + fifoBufferHeaderSize, temp, cSize); + //listen to after the carry over buffer + if(status != TRANSMITTING) + receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + fifoBufferHeaderSize + cSize, + (bufferSize * numberofJobsPerBuffer) - cSize); - if(!activated){ + //write packet count to buffer + *((uint32_t*)(buffer[ithread])) = (receivedSize/onePacketSize); + totalListeningPacketCount[ithread] += (receivedSize/onePacketSize); - //cSize = 0 for deactivated - int framestoclone = 0; - //first - if(deactivatedFrameNumber[ithread]==0) - deactivatedFrameNumber[ithread]++; - //done - if(deactivatedFrameNumber[ithread] == (numberOfFrames+1)) - return 0; - //last - if((deactivatedFrameNumber[ithread] + deactivatedFrameIncrement) > (numberOfFrames+1)) - framestoclone = (numberOfFrames+1) - deactivatedFrameNumber[ithread]; - //in progress - else - framestoclone = deactivatedFrameIncrement; + //start indices for each start of scan/acquisition + if((!measurementStarted[ithread]) && (receivedSize > 0)) + startFrameIndices(ithread); - //copy dummy packets - receivedSize = framestoclone*packetsPerFrame*onePacketSize; - memset(buffer[ithread] + fifoBufferHeaderSize, 0xFF,receivedSize); - - //set fnum, pnum and deactivatedpacket label - eiger_packet_header_t* header; - eiger_packet_footer_t* footer; - uint32_t pnum=0; - //loop by each packet - for(int offset=fifoBufferHeaderSize; - offsetpacketNumber) = ++pnum; -#ifdef MANUALDEBUG - if(!ithread){ - cprintf(GREEN,"thread:%d pnum:%d fnum:%d\n", - ithread, - (*( (uint16_t*) footer->packetNumber)), - (uint32_t)(*( (uint64_t*) footer))); - } -#endif - if(pnum == packetsPerFrame){ - pnum = 0; - deactivatedFrameNumber[ithread]++; - } - } - - return receivedSize; - } - - - if(myDetectorType == JUNGFRAU){ - - jfrau_packet_header_t* header; - int offset = fifoBufferHeaderSize; - uint32_t pnum = packetsPerFrame-1; - uint32_t currentpnum; - - //read first packet - receivedSize=0; - if(status != TRANSMITTING) - receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + offset); - if(!receivedSize) return 0; - header = (jfrau_packet_header_t*)(buffer[ithread] + offset); - currentpnum = (*( (uint8_t*) header->packetNumber)); - //cout<<"1 currentpnum:"<frameNumber))&frameIndexMask); - (*((uint64_t*)(buffer[ithread]+HEADER_SIZE_NUM_TOT_PACKETS+JFRAU_FILE_HEADER_BUNCHID_OFFSET))) = (*( (uint64_t*) header->bunchid)); - //cout<<"current fnum:"<<(*((uint32_t*)(buffer[ithread]+8)))<ReceiveDataOnly(buffer[ithread] + offset); - if(!receivedSize){ - totalIgnoredPacketCount[ithread] += (packetsPerFrame - pnum); - return 0; - } - totalListeningPacketCount[ithread]++; - header = (jfrau_packet_header_t*)(buffer[ithread] + offset); - currentpnum = (*( (uint8_t*) header->packetNumber)); - //cout<<"next currentpnum :"<ReceiveDataOnly(buffer[ithread] + offset); - if(!receivedSize) return 0; - totalListeningPacketCount[ithread]++; - header = (jfrau_packet_header_t*)(buffer[ithread] + offset); - currentpnum = (*( (uint8_t*) header->packetNumber)); - //cout<<"trying to find: currentpnum:"<ReceiveDataOnly(buffer[ithread] + fifoBufferHeaderSize + cSize, (bufferSize * numberofJobsPerBuffer) - cSize); - //eiger returns 0 when header packet caught - while(receivedSize < onePacketSize && status != TRANSMITTING) - receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + fifoBufferHeaderSize + cSize, (bufferSize * numberofJobsPerBuffer) - cSize); - - - } - - totalListeningPacketCount[ithread] += (receivedSize/onePacketSize); - - -#ifdef MANUALDEBUG - if(receivedSize>0){ - if(myDetectorType == JUNGFRAU){ - jfrau_packet_header_t* header; - - for(int iloop=0;iloop<128;iloop++){ - header = (jfrau_packet_header_t*)(buffer[ithread] + fifoBufferHeaderSize + iloop * (JFRAU_HEADER_LENGTH+JFRAU_ONE_DATA_SIZE)); - cprintf(RED,"[%d]: packetnumber:%d\n",iloop, (*( (uint8_t*) header->packetNumber))); - cprintf(RED," : framenumber :%d\n", (*( (uint32_t*) header->frameNumber))&frameIndexMask); - } - }else if(myDetectorType == EIGER){ - eiger_packet_header_t* header = (eiger_packet_header_t*) (buffer[ithread]+fifoBufferHeaderSize); - eiger_packet_footer_t* footer = (eiger_packet_footer_t*)(buffer[ithread] + footerOffset + fifoBufferHeaderSize); - cprintf(GREEN,"thread:%d footeroffset:%dsubframenum:%d oldpacketnum:%d new pnum:%d new fnum:%d\n", - ithread,footerOffset, - (*( (unsigned int*) header->subFrameNumber)), - (*( (uint8_t*) header->dynamicRange)), - (*( (uint16_t*) footer->packetNumber)), - (uint32_t)(*( (uint64_t*) footer))); - } - } -#endif #ifdef DEBUG cprintf(BLUE, "Listening_Thread %d : Received bytes: %d. Expected bytes: %d\n", ithread, receivedSize, bufferSize * numberofJobsPerBuffer-cSize); #endif @@ -2312,16 +2138,188 @@ int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int cSize, ch + +int UDPStandardImplementation::prepareAndListenBufferDeactivated(int ithread){ + FILE_LOG(logDEBUG) << __AT__ << " called"; + + //last + if(currentFrameNumber[ithread] == numberOfFrames) + return 0; + + //copy dummy packets + memset(buffer[ithread] + fifoBufferHeaderSize, 0xFF,bufferSize); + + //write fnum and number of packets + (*((uint64_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS))) = currentFrameNumber[ithread]+1; + (*((uint32_t*)(buffer[ithread]))) = packetsPerFrame; + + //start indices for each start of scan/acquisition (rc > 0) + if(!measurementStarted[ithread]) + startFrameIndices(ithread); + + return bufferSize; +} + + + + +int UDPStandardImplementation::prepareAndListenBufferCompleteFrames(int ithread){ + FILE_LOG(logDEBUG) << __AT__ << " called"; + + int headerlength = 0; + uint32_t LASTPNUM = 0; + uint32_t FIRSTPNUM = 0; + int INCORDECR = 0; + switch(myDetectorType){ + case JUNGFRAU: + headerlength = JFRAU_HEADER_LENGTH; + FIRSTPNUM = packetsPerFrame-1; + LASTPNUM = 0; + INCORDECR = -1; + break; + case EIGER: + headerlength = EIGER_DATA_PACKET_HEADER_SIZE; + FIRSTPNUM = 0; + LASTPNUM = packetsPerFrame-1; + INCORDECR = 1; + break; + default:break; + } + + + int offset = fifoBufferHeaderSize; + uint32_t pnum = 0; + uint64_t fnum = 0; + uint64_t bnum = 0; + int rc = 0; + //from getframeandpacketnumber() + uint32_t pi = 0; + uint64_t fi = 0; + uint64_t bi = 0; + uint32_t si = 0; + + + //read first packet + pnum = FIRSTPNUM; //first packet number to validate + if(status != TRANSMITTING) rc = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + offset); + if(!rc) return 0; + if(getFrameandPacketNumber(ithread,buffer[ithread] + offset,fi,pi,si,bi) == FAIL) + pi = ALL_MASK_32; //got 0 from fpga + fnum = fi; //fnum of first packet + bnum = bi; //bnum of first packet + totalListeningPacketCount[ithread]++; +#ifdef VERBOSE + if(!ithread) cout << "1 pnum:" << pnum << endl; +#endif + //start indices for each start of scan/acquisition (rc > 0) + if(!measurementStarted[ithread]) + startFrameIndices(ithread); + + + while(true){ + + //------------------------------------------------------ correct packet -------------------------------------------------------- + if((myDetectorType == JUNGFRAU && pnum == pi) || //jungfrau only looks at pnum + (myDetectorType == EIGER && pnum == pi && fnum == fi)){ // eiger looks at pnum and fnum +#ifdef VERBOSE + if(!ithread) cout << "correct packet" << endl; +#endif + //copy only data + memcpy(buffer[ithread] + offset,buffer[ithread] + offset + headerlength, oneDataSize); + offset+=oneDataSize; + + //if complete frame + if(pnum == LASTPNUM) + break; + //else increment/decrement + pnum += INCORDECR; + + rc=0; //listen again + if(status != TRANSMITTING) + rc = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + offset); + if(!rc){ //end: update ignored and return + if(myDetectorType == JUNGFRAU) + totalIgnoredPacketCount[ithread] += (packetsPerFrame - pnum); + else + totalIgnoredPacketCount[ithread] += (pnum + 1); + return 0; + } + totalListeningPacketCount[ithread]++; + if(getFrameandPacketNumber(ithread, buffer[ithread] + offset,fi,pi,si,bi) == FAIL) + pi = ALL_MASK_32; //got 0 from fpga + if(myDetectorType == EIGER) + fnum = fi; //update currentfnum for eiger (next packets should have currentfnum value) +#ifdef VERBOSE + if(!ithread) cout << "next currentpnum :" << pnum << endl; +#endif + } + + //------------------------------------------------------ wrong packet -------------------------------------------------------- + else{ +#ifdef VERBOSE + if(!ithread) cprintf(RED,"wrong packet %d, expected packet %d fnum of last good one:%d\n", + pi,pnum,(*((uint32_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS)))); +#endif + if(myDetectorType == JUNGFRAU) + totalIgnoredPacketCount[ithread] += (packetsPerFrame - pnum -1); //extra 1 subtracted now to be added in the while loop anyway + else + totalIgnoredPacketCount[ithread] += pnum; //extra 1 subtracted now to be added in the while loop anyway + pnum = FIRSTPNUM; + offset = fifoBufferHeaderSize; + + //find the start of next image + while(pnum != pi){ + totalIgnoredPacketCount[ithread]++; + + rc=0; + if(status != TRANSMITTING) + rc = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + offset); + if(!rc){ + if(myDetectorType == JUNGFRAU) + totalIgnoredPacketCount[ithread] += (packetsPerFrame - pnum); + else + totalIgnoredPacketCount[ithread] += (pnum + 1); + return 0; + } + totalListeningPacketCount[ithread]++; + if(getFrameandPacketNumber(ithread, buffer[ithread] + offset,fi,pi,si,bi) == FAIL) + pi = ALL_MASK_32; //got 0 from fpga +#ifdef VERBOSE + if(!ithread) cout << "trying to find pnum:" << pnum << " got " << pi << endl; +#endif + } + fnum = fi; //fnum of first packet + bnum = bi; //bnum of first packet + } + } + //------------------------------------------------------ got a complete frame -------------------------------------------------------- + + //write frame number + (*((uint64_t*)(buffer[ithread]+HEADER_SIZE_NUM_TOT_PACKETS))) = fnum + startAcquisitionIndex; +#ifdef VERBOSE + if(!ithread) cout << "fnum:" << (*((uint64_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS))) << endl; +#endif + if(myDetectorType == JUNGFRAU) + (*((uint64_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS + FILE_HEADER_BUNCHID_OFFSET))) = bnum; + //write packet count to buffer + *((uint32_t*)(buffer[ithread])) = packetsPerFrame; + return bufferSize; +} + + + void UDPStandardImplementation::startFrameIndices(int ithread){ FILE_LOG(logDEBUG) << __AT__ << " called"; - //determine startFrameIndex + + jfrau_packet_header_t* header=0; switch(myDetectorType){ case EIGER: - startFrameIndex = 0; //frame number always resets + startFrameIndex = 1; //frame number always resets break; case JUNGFRAU: - startFrameIndex = (*((uint32_t*)(buffer[ithread]+HEADER_SIZE_NUM_TOT_PACKETS))); + header = (jfrau_packet_header_t*)(buffer[ithread]+HEADER_SIZE_NUM_TOT_PACKETS); + startFrameIndex = (*( (uint32_t*) header->frameNumber))&frameIndexMask; break; default: if(shortFrameEnable < 0){ @@ -2361,103 +2359,45 @@ void UDPStandardImplementation::stopListening(int ithread, int numbytes){ cprintf(BLUE,"Listening_Thread %d: Stop Listening\nStatus: %s numbytes:%d\n", ithread, runStatusType(status).c_str(),numbytes); #endif - //less than 1 packet size (especially for eiger), ignore the buffer (so that 2 dummy buffers are not sent with pc=0) - if(numbytes < onePacketSize) - numbytes = 0; - - //free empty buffer if(numbytes <= 0){ FILE_LOG(logINFO) << "Listening "<< ithread << ": End of Acquisition"; while(!fifoFree[ithread]->push(buffer[ithread])); -#ifdef EVERYFIFODEBUG - if(fifoFree[ithread]->getSemValue()<100) - cprintf(GREEN,"Fifofree[%d]: value:%d, push 0x%x\n",ithread,fifoFree[ithread]->getSemValue(),(void*)(buffer[ithread])); -#endif -#ifdef CFIFODEBUG - if(ithread == 0) - cprintf(CYAN,"Listening_Thread %d :Listener push empty buffer into fifofree %p\n", ithread, (void*)(buffer[ithread])); - else - cprintf(YELLOW,"Listening_Thread %d :Listener push empty buffer into fifofree %p\n", ithread, (void*)(buffer[ithread])); -#endif } //push last non empty buffer into fifo else{ - (*((uint32_t*)(buffer[ithread]))) = numbytes/onePacketSize; - totalListeningPacketCount[ithread] += (numbytes/onePacketSize); + if(excludeMissingPackets){ + (*((uint32_t*)(buffer[ithread]))) = numbytes/oneDataSize; + totalListeningPacketCount[ithread] += (numbytes/oneDataSize); + }else{ + (*((uint32_t*)(buffer[ithread]))) = numbytes/onePacketSize; + totalListeningPacketCount[ithread] += (numbytes/onePacketSize); + } #ifdef DEBUG cprintf(BLUE,"Listening_Thread %d: Last Buffer numBytes:%d\n",ithread, numbytes); - cprintf(BLUE,"Listening_Thread %d: Last Buffer packet count:%d\n",ithread, numbytes/onePacketSize); + cprintf(BLUE,"Listening_Thread %d: Last Buffer packet count:%d\n",ithread,(*((uint32_t*)(buffer[ithread]))) ); #endif while(!fifo[ithread]->push(buffer[ithread])); -#ifdef EVERYFIFODEBUG - if(fifo[ithread]->getSemValue()>(fifoSize-100)) - cprintf(MAGENTA,"Fifo[%d]: value:%d, push 0x%x\n",ithread,fifo[ithread]->getSemValue(),(void*)(buffer[ithread])); -#endif -#ifdef CFIFODEBUG - if(ithread == 0) - cprintf(CYAN,"Listening_Thread %d: Listener Last Buffer pushed into fifo %p\n", ithread,(void*)(buffer[ithread])); - else - cprintf(YELLOW,"Listening_Thread %d: Listener Last Buffer pushed into fifo %p\n", ithread,(void*)(buffer[ithread])); -#endif } //push dummy-end buffer into fifo for all writer threads fifoFree[ithread]->pop(buffer[ithread]); -#ifdef EVERYFIFODEBUG - if(fifoFree[ithread]->getSemValue()<100) - cprintf(BLUE,"FifoFree[%d]: value:%d, pop 0x%x\n",ithread,fifoFree[ithread]->getSemValue(),(void*)(buffer[ithread])); -#endif -#ifdef CFIFODEBUG - if(ithread == 0) - cprintf(CYAN,"Listening_Thread %d: Popped Dummy from fifoFree %p\n", ithread,(void*)(buffer[ithread])); - else - cprintf(YELLOW,"Listening_Thread %d: Popped Dummy from fifoFree %p\n", ithread,(void*)(buffer[ithread])); -#endif + //creating dummy-end buffer with pc=0xFFFF (*((uint32_t*)(buffer[ithread]))) = dummyPacketValue; while(!fifo[ithread]->push(buffer[ithread])); -#ifdef EVERYFIFODEBUG - if(fifo[ithread]->getSemValue()>(fifoSize-100)) - cprintf(MAGENTA,"Fifo[%d]: value:%d, push 0x%x\n",ithread,fifo[ithread]->getSemValue(),(void*)(buffer[ithread])); -#endif -#ifdef CFIFODEBUG - if(ithread == 0) - cprintf(CYAN,"Listening_Thread %d: Listener pushed dummy-end buffer into fifo %p\n", ithread,(void*)(buffer[ithread])); - else - cprintf(YELLOW,"Listening_Thread %d: Listener pushed dummy-end buffer into fifo %p\n", ithread,(void*)(buffer[ithread])); -#endif - //reset mask and exit loop pthread_mutex_lock(&statusMutex); listeningThreadsMask^=(1< 1) - cprintf(BLUE,"Listening_Thread %d: Waiting for other listening threads to be done.. current mask:0x%x\n", ithread, listeningThreadsMask); -#endif - while(listeningThreadsMask) - usleep(5000); -#ifdef DEBUG4 - int t=0; - for(i=0;iframeNumber))&frameIndexMask, - (*( (uint8_t*) header->packetNumber))); -#endif - header = (jfrau_packet_header_t*) (buffer[ithread]+lastPacketOffset); -#ifdef DEBUG4 - cprintf(BLUE, "Listening_Thread: Last Header:%du\t Last Packet:%d\n", - (*( (uint32_t*) header->frameNumber))&frameIndexMask, - (*( (uint8_t*) header->packetNumber))); -#endif - //jungfrau last packet value is 0, so find the last packet and store the others in a temp storage - if((*( (uint8_t*) header->packetNumber))){ - //cprintf(RED,"entering missing packet zone\n"); - lastFrameHeader64 = (*( (uint32_t*) header->frameNumber))&frameIndexMask; - cSize += onePacketSize; - lastPacketOffset -= onePacketSize; - --packetCount; - while (lastFrameHeader64 == ((*( (uint32_t*) header->frameNumber))&frameIndexMask)){ - cSize += onePacketSize; - lastPacketOffset -= onePacketSize; - header = (jfrau_packet_header_t*) (buffer[ithread]+lastPacketOffset); -#ifdef DEBUG4 - cprintf(RED,"new header:%d new packet:%d\n", - (*( (uint32_t*) header->frameNumber))&frameIndexMask, - (*( (uint8_t*) header->packetNumber))); -#endif - --packetCount; - } - memcpy(temp, buffer[ithread]+(lastPacketOffset+onePacketSize), cSize); - } - - break; - default: cprintf(RED,"Listening_Thread %d: Error: This detector %s is not implemented in the receiver\n", ithread, getDetectorType(myDetectorType).c_str()); @@ -2591,15 +2493,12 @@ uint32_t UDPStandardImplementation::processListeningBuffer(int ithread, int &cSi void UDPStandardImplementation::startWriting(){ FILE_LOG(logDEBUG) << __AT__ << " called"; - //set current thread value index - int ithread = currentThreadIndex; - //let calling function know thread started and obtained current - threadStarted = 1; + int ithread = currentThreadIndex; //set current thread value index + threadStarted = 1; //let calling function know thread started and obtained current - //variable definitions - char* wbuf=NULL; //buffer popped from FIFO + char* wbuf = NULL; //buffer popped from FIFO sfilefd[ithread] = 0; //file pointer - uint64_t nf=0; //for compression, number of frames + uint64_t nf = 0; //for compression, number of frames int listenfifoIndex = ithread; @@ -2607,10 +2506,12 @@ void UDPStandardImplementation::startWriting(){ //infinite loop, exited only to change dynamic range, 10G parameters etc (then recreated again) while(true){ - //--reset parameters before acquisition - nf = 0; + //--reset parameters before acquisition (depending on compression) + nf = 0; //compression has only one listening thread (anything not eiger) if(dataCompressionEnable) - listenfifoIndex = 0; //compression has only one listening thread + listenfifoIndex = 0; //compression has only one listening thread (anything not eiger) + else + listenfifoIndex = ithread; /* inner loop - loop for each buffer */ @@ -2618,13 +2519,6 @@ void UDPStandardImplementation::startWriting(){ while((1 << ithread) & writerThreadsMask){ //pop fifo[listenfifoIndex]->pop(wbuf); -#ifdef EVERYFIFODEBUG - if(fifo[listenfifoIndex]->getSemValue()>(fifoSize-100)) - cprintf(CYAN,"Fifo[%d]: value:%d, pop 0x%x\n",listenfifoIndex,fifo[listenfifoIndex]->getSemValue(),(void*)(wbuf)); -#endif -#ifdef DEBUG4 - cprintf(GREEN,"Writing_Thread %d: Popped %p from FIFO %d\n", ithread, (void*)(wbuf),listenfifoIndex); -#endif uint32_t numPackets = (uint32_t)(*((uint32_t*)wbuf)); #ifdef DEBUG4 cprintf(GREEN,"Writing_Thread %d: Number of Packets: %d for FIFO %d\n", ithread, numPackets, listenfifoIndex); @@ -2640,11 +2534,9 @@ void UDPStandardImplementation::startWriting(){ continue; } - - - //jungfrau - if(myDetectorType == JUNGFRAU) - handleWithoutMissingPackets(ithread, wbuf, numPackets); + //jungfrau and eiger + if(excludeMissingPackets) + handleCompleteFramesOnly(ithread, wbuf); //normal else if(!dataCompressionEnable) handleWithoutDataCompression(ithread, wbuf, numPackets); @@ -2697,10 +2589,6 @@ void UDPStandardImplementation::waitWritingBufferForNextAcquisition(int ithread) cprintf(RED,"%d:fifo emptied\n", ithread); fifo[ithread]->pop(temp); fifoFree[ithread]->push(temp); -#ifdef EVERYFIFODEBUG - if(fifo[ithread]->getSemValue()>(fifoSize-100)) - cprintf(CYAN,"Fifo[%d]: value:%d, pop 0x%x\n",ithread,fifo[ithread]->getSemValue(),(void*)(temp)); -#endif } //create file @@ -2779,60 +2667,51 @@ void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer){ //free fifo while(!fifoFree[ithread]->push(wbuffer)); -#ifdef EVERYFIFODEBUG - if(fifoFree[ithread]->getSemValue()<100) - cprintf(GREEN,"FifoFree[%d]: value:%d, push 0x%x\n",ithread,fifoFree[ithread]->getSemValue(),(void*)(wbuffer)); -#endif -#ifdef CFIFODEBUG - if(ithread==0) - cprintf(CYAN,"Writing_Thread %d: Freeing dummy-end buffer. Pushed into fifofree %p for listener %d\n", ithread,(void*)(wbuffer),ithread); - else - cprintf(YELLOW,"Writing_Thread %d: Freeing dummy-end buffer. Pushed into fifofree %p for listener %d\n", ithread,(void*)(wbuffer),ithread); -#endif if(dataStreamEnable){ - //ensure previous frame was processed - sem_wait(&writerGuiSemaphore[ithread]); + sem_wait(&writerGuiSemaphore[ithread]); //ensure previous frame was processed guiNumPackets[ithread] = dummyPacketValue; - //let it know its got data - sem_post(&dataCallbackWriterSemaphore[ithread]); + sem_post(&dataCallbackWriterSemaphore[ithread]); //let it know its got data } //all threads need to close file, reset mask and exit loop - missingPacketinFile = (long long int)numberOfFrames*packetsPerFrame-totalWritingPacketCount[ithread]; - if(myDetectorType == EIGER && fileWriteEnable && (cbAction > DO_NOTHING) && missingPacketinFile){ + if(myDetectorType == EIGER && fileWriteEnable && (cbAction > DO_NOTHING)){ updateFileHeader(ithread); fseek(sfilefd[ithread],0,0); fwrite((void*)fileHeader[ithread], 1, FILE_HEADER_SIZE, sfilefd[ithread]); } //Print packet loss - if(totalWritingPacketCountFromLastCheck[ithread]){ + //if(totalWritingPacketCountFromLastCheck[ithread]){ if(numberofWriterThreads>1){ printf("Thread:%d" "\tLost:%lld" - "\tPackets:%lld" + "\t\tPackets:%lld" "\tFrame#:%lld" - "\tPFrame#r:%lld\n", + "\tPFrame#:%lld\n", ithread, - (long long int)(((currentFrameNumber[ithread]-frameNumberInPreviousCheck[ithread])*packetsPerFrame) - totalWritingPacketCountFromLastCheck[ithread]), + ((frameNumberInPreviousCheck[ithread]+1+(maxFramesPerFile/progressFrequency))>numberOfFrames) + ?(long long int)((numberOfFrames-(frameNumberInPreviousCheck[ithread]+1))*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]) + :(long long int)((frameNumberInPreviousCheck[ithread]+(maxFramesPerFile/progressFrequency) - frameNumberInPreviousCheck[ithread])*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]), (long long int)totalWritingPacketCountFromLastCheck[ithread], (long long int)currentFrameNumber[ithread], (long long int)frameNumberInPreviousCheck[ithread] ); }else{ printf("Lost:%lld" - "\tPackets:%lld" + "\t\tPackets:%lld" "\tFrame#:%lld" "\tPFrame#:%lld\n", - (long long int)(((currentFrameNumber[ithread]-frameNumberInPreviousCheck[ithread])*packetsPerFrame) - totalWritingPacketCountFromLastCheck[ithread]), + ((frameNumberInPreviousCheck[ithread]+1+(maxFramesPerFile/progressFrequency))>numberOfFrames) + ?(long long int)((numberOfFrames-(frameNumberInPreviousCheck[ithread]+1))*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]) + :(long long int)((frameNumberInPreviousCheck[ithread]+(maxFramesPerFile/progressFrequency) - frameNumberInPreviousCheck[ithread])*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]), (long long int)totalWritingPacketCountFromLastCheck[ithread], (long long int)currentFrameNumber[ithread], (long long int)frameNumberInPreviousCheck[ithread] ); } - } + //} closeFile(ithread); pthread_mutex_lock(&statusMutex); @@ -2865,7 +2744,7 @@ void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer){ if(totalWritingPacketCount[i] < ((uint64_t)numberOfFrames*packetsPerFrame)){ cprintf(RED, "\nPort %d\n",udpPortNum[i]); - if(myDetectorType == JUNGFRAU){ + if(excludeMissingPackets){ cprintf(RED, "Ignored Packets \t: %lld\n",(long long int)totalIgnoredPacketCount[i]); cprintf(RED, "Missing Packets \t: %lld\n",(long long int)numberOfFrames*packetsPerFrame-totalWritingPacketCount[i]-totalIgnoredPacketCount[i]); }else @@ -2880,7 +2759,7 @@ void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer){ cprintf(RED, "Last Frame Number Caught :%lld\n",(long long int)lastFrameNumber); }else{ cprintf(GREEN, "\nPort %d\n",udpPortNum[i]); - if(myDetectorType == JUNGFRAU){ + if(excludeMissingPackets){ cprintf(GREEN, "Ignored Packets \t: %lld\n",(long long int)totalIgnoredPacketCount[i]); cprintf(GREEN, "Missing Packets \t: %lld\n",(long long int)numberOfFrames*packetsPerFrame-totalWritingPacketCount[i]-totalIgnoredPacketCount[i]); }else @@ -2913,7 +2792,8 @@ void UDPStandardImplementation::handleWithoutDataCompression(int ithread, char* uint64_t tempframenumber; uint32_t pnum; uint32_t snum; - if(getFrameandPacketNumber(ithread, wbuffer + fifoBufferHeaderSize,tempframenumber,pnum,snum) == FAIL){ + uint64_t bunchid; + if(getFrameandPacketNumber(ithread, wbuffer + fifoBufferHeaderSize,tempframenumber,pnum,snum,bunchid) == FAIL){ //error in frame number sent by fpga while(!fifoFree[ithread]->push(wbuffer)); @@ -2962,96 +2842,102 @@ void UDPStandardImplementation::handleWithoutDataCompression(int ithread, char* -void UDPStandardImplementation::handleWithoutMissingPackets(int ithread, char* wbuffer, uint32_t npackets){ +void UDPStandardImplementation::handleCompleteFramesOnly(int ithread, char* wbuffer){ FILE_LOG(logDEBUG) << __AT__ << " called"; //get current frame number uint64_t tempframenumber; - tempframenumber = (*((uint32_t*)(wbuffer+HEADER_SIZE_NUM_TOT_PACKETS))); - //cout<<"handling: before frame number:"< 0){ - if((fileWriteEnable) && (sfilefd[ithread])){ - if(tempframenumber && (tempframenumber%maxFramesPerFile) == 0){ - createNewFile(ithread); - } - fwrite(wbuffer + HEADER_SIZE_NUM_TOT_PACKETS, 1, oneDataSize*packetsPerFrame+fifoBufferHeaderSize-HEADER_SIZE_NUM_TOT_PACKETS, sfilefd[ithread]); - } + if((fileWriteEnable) && (sfilefd[ithread])){ + if(tempframenumber && (tempframenumber%maxFramesPerFile) == 0) + createNewFile(ithread); + fwrite(wbuffer + HEADER_SIZE_NUM_TOT_PACKETS, 1, bufferSize + FILE_FRAME_HEADER_LENGTH, sfilefd[ithread]); + } - - //Print packet loss and filenames - if(tempframenumber && (tempframenumber%(maxFramesPerFile/10)) == 0){ - printf("Lost:%lld" - "\tPackets:%lld" + //progress + if(tempframenumber && (tempframenumber%(maxFramesPerFile/progressFrequency)) == 0){ + if(numberofWriterThreads>1){ + printf("Thread:%d" + "\tLost:%lld" + "\t\tPackets:%lld" "\tFrame#:%lld" "\tPFrame#:%lld\n", - (long long int)(((currentFrameNumber[ithread]-frameNumberInPreviousCheck[ithread])*packetsPerFrame) - totalWritingPacketCountFromLastCheck[ithread]), + ithread, + ((frameNumberInPreviousCheck[ithread]+1+(maxFramesPerFile/progressFrequency))>numberOfFrames) + ?(long long int)((numberOfFrames-(frameNumberInPreviousCheck[ithread]+1))*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]) + :(long long int)((frameNumberInPreviousCheck[ithread]+(maxFramesPerFile/progressFrequency) - frameNumberInPreviousCheck[ithread])*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]), + (long long int)totalWritingPacketCountFromLastCheck[ithread], + (long long int)currentFrameNumber[ithread], + (long long int)frameNumberInPreviousCheck[ithread] + ); + }else{ + printf("Lost:%lld" + "\t\tPackets:%lld" + "\tFrame#:%lld" + "\tPFrame#:%lld\n", + ((frameNumberInPreviousCheck[ithread]+1+(maxFramesPerFile/progressFrequency))>numberOfFrames) + ?(long long int)((numberOfFrames-(frameNumberInPreviousCheck[ithread]+1))*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]) + :(long long int)((frameNumberInPreviousCheck[ithread]+(maxFramesPerFile/progressFrequency) - frameNumberInPreviousCheck[ithread])*packetsPerFrame - totalWritingPacketCountFromLastCheck[ithread]), (long long int)totalWritingPacketCountFromLastCheck[ithread], (long long int)currentFrameNumber[ithread], (long long int)frameNumberInPreviousCheck[ithread] ); - - //reset counters for each new file - frameNumberInPreviousCheck[ithread] = currentFrameNumber[ithread]; - totalWritingPacketCountFromLastCheck[ithread] = 0; } - - - if(npackets!=128) exit(-1);/******************/ - totalWritingPacketCountFromLastCheck[ithread]+= npackets; - totalPacketsInFile[ithread] += npackets; - totalWritingPacketCount[ithread] += npackets; - lastFrameNumberInFile[ithread] = tempframenumber; - currentFrameNumber[ithread] = tempframenumber; - //cout<<"curentframenumber:"< 1) - pthread_mutex_lock(&writeMutex); - packetsCaught += npackets; - totalPacketsCaught += npackets; - if((currentFrameNumber[ithread] - startAcquisitionIndex) > acquisitionIndex) - acquisitionIndex = currentFrameNumber[ithread] - startAcquisitionIndex; - if((currentFrameNumber[ithread] - startFrameIndex) > frameIndex[ithread]) - frameIndex[ithread] = currentFrameNumber[ithread] - startFrameIndex; - - if(numberofWriterThreads > 1) - pthread_mutex_unlock(&writeMutex); - + //reset counters for each new file + frameNumberInPreviousCheck[ithread] = currentFrameNumber[ithread]; + totalWritingPacketCountFromLastCheck[ithread] = 0; } + + totalWritingPacketCountFromLastCheck[ithread]+= packetsPerFrame; + totalPacketsInFile[ithread] += packetsPerFrame; + totalWritingPacketCount[ithread] += packetsPerFrame; + lastFrameNumberInFile[ithread] = tempframenumber; + currentFrameNumber[ithread] = tempframenumber; + //cout<<"curentframenumber:"< 1) + pthread_mutex_lock(&writeMutex); + + packetsCaught += packetsPerFrame; + totalPacketsCaught += packetsPerFrame; + if((currentFrameNumber[ithread] - startAcquisitionIndex) > acquisitionIndex) + acquisitionIndex = currentFrameNumber[ithread] - startAcquisitionIndex; + if((currentFrameNumber[ithread] - startFrameIndex) > frameIndex[ithread]) + frameIndex[ithread] = currentFrameNumber[ithread] - startFrameIndex; + + if(numberofWriterThreads > 1) + pthread_mutex_unlock(&writeMutex); + + if(!activated) + currentFrameNumber[ithread]++; + #ifdef DEBUG4 cprintf(GREEN,"Writing_Thread: Writing done\nGoing to copy frame\n"); #endif //copy frame for gui - //if(npackets >= (packetsPerFrame/numberofListeningThreads)) - if(dataStreamEnable && npackets > 0) - copyFrameToGui(ithread, wbuffer,npackets); + if(dataStreamEnable) + copyFrameToGui(ithread, wbuffer, packetsPerFrame); #ifdef DEBUG4 cprintf(GREEN,"Writing_Thread: Copied frame\n"); #endif //free fifo addresses - int listenfifoThread = ithread; - if(dataCompressionEnable) - listenfifoThread = 0; - while(!fifoFree[listenfifoThread]->push(wbuffer)); -#ifdef EVERYFIFODEBUG - if(fifoFree[listenfifoThread]->getSemValue()<100) - cprintf(GREEN,"FifoFree[%d]: value:%d, push 0x%x\n",listenfifoThread,fifoFree[listenfifoThread]->getSemValue(),(void*)(wbuffer)); -#endif + while(!fifoFree[ithread]->push(wbuffer)); #ifdef DEBUG5 - cprintf(GREEN,"Writing_Thread %d: Freed buffer, pushed into fifofree %p for listener %d \n",listenfifoThread, (void*)(wbuffer), listenfifoThread); + cprintf(GREEN,"Writing_Thread %d: Freed buffer, pushed into fifofree %p for listener %d \n",ithread, (void*)(wbuffer), ithread); #endif } @@ -3076,8 +2962,9 @@ void UDPStandardImplementation::writeFileWithoutCompression(int ithread, char* w uint64_t startframe = 0; uint32_t pnum = 0; uint32_t snum = 0; + uint64_t bunchid = 0; //if(ithread) cout<<"getting start frame number"<push(wbuffer)); return; @@ -3136,7 +3023,8 @@ void UDPStandardImplementation::writeFileWithoutCompression(int ithread, char* w uint64_t finalLastFrameNumberToSave = 0; uint32_t pnum; uint32_t snum; - if(getFrameandPacketNumber(ithread, wbuffer + fifoBufferHeaderSize + ((numpackets - 1) * onePacketSize), finalLastFrameNumberToSave,pnum,snum) == FAIL){ + uint64_t bunchid = 0; + if(getFrameandPacketNumber(ithread, wbuffer + fifoBufferHeaderSize + ((numpackets - 1) * onePacketSize), finalLastFrameNumberToSave,pnum,snum,bunchid) == FAIL){ //error in frame number sent by fpga while(!fifoFree[ithread]->push(wbuffer)); return; @@ -3176,18 +3064,18 @@ void UDPStandardImplementation::updateFileHeader(int ithread){ "Top\t\t: %d\n" "Left\t\t: %d\n" "Active\t\t: %d\n" - "Packets Lost\t: %d\n" + "Frames Caught\t: %d\n" + "Frames Lost\t: %d\n" "Dynamic Range\t: %d\n" "Ten Giga\t: %d\n" "Packet\t\t: %d bytes\n" "Data\t\t: %d bytes\n" "x\t\t: %d pixels\n" "y\t\t: %d pixels\n" - "Frames\t\t: %lld\n" + "Total Frames\t: %lld\n" "Exptime (ns)\t: %lld\n" "Period (ns)\t: %lld\n" "Timestamp\t: %s\n\n" - //only for eiger right now "#Packet Header\n" "Subframe Number\t: 4 bytes\n" @@ -3200,7 +3088,10 @@ void UDPStandardImplementation::updateFileHeader(int ithread){ FILE_HEADER_SIZE, (bottomEnable?0:1),(ithread?0:1), activated, - missingPacketinFile, + (long long int)(totalPacketsInFile[ithread]/packetsPerFrame), + ((frameNumberInPreviousFile[ithread]+1+maxFramesPerFile)>numberOfFrames) + ?(long long int)((numberOfFrames-(frameNumberInPreviousFile[ithread]+1)) - (totalPacketsInFile[ithread]/packetsPerFrame)) + :(long long int)((frameNumberInPreviousFile[ithread]+maxFramesPerFile - frameNumberInPreviousFile[ithread]) - (totalPacketsInFile[ithread]/packetsPerFrame)), dynamicRange,tengigaEnable, onePacketSize,oneDataSize, //only for eiger right now @@ -3234,8 +3125,8 @@ void UDPStandardImplementation::copyFrameToGui(int ithread, char* buffer, uint32 //copy date guiNumPackets[ithread] = numpackets; strcpy(guiFileName[ithread],completeFileName[ithread]); - if(myDetectorType == JUNGFRAU) //copy also the header - memcpy(latestData[ithread],buffer+HEADER_SIZE_NUM_TOT_PACKETS, bufferSize+fifoBufferHeaderSize-HEADER_SIZE_NUM_TOT_PACKETS); + if(excludeMissingPackets) //copy also the header + memcpy(latestData[ithread],buffer+HEADER_SIZE_NUM_TOT_PACKETS, bufferSize + FILE_FRAME_HEADER_LENGTH); else //copy only the data memcpy(latestData[ithread],buffer+ fifoBufferHeaderSize , numpackets*onePacketSize); //let it know its got data @@ -3265,7 +3156,8 @@ void UDPStandardImplementation::handleDataCompression(int ithread, char* wbuffer uint64_t tempframenumber=-1; uint32_t pnum; uint32_t snum; - if(getFrameandPacketNumber(ithread, wbuffer + fifoBufferHeaderSize, tempframenumber,pnum,snum) == FAIL){ + uint64_t bunchid=-1; + if(getFrameandPacketNumber(ithread, wbuffer + fifoBufferHeaderSize, tempframenumber,pnum,snum,bunchid) == FAIL){ //error in frame number sent by fpga while(!fifoFree[ithread]->push(wbuffer)); return; @@ -3401,7 +3293,7 @@ void UDPStandardImplementation::handleDataCompression(int ithread, char* wbuffer -int UDPStandardImplementation::getFrameandPacketNumber(int ithread, char* wbuffer, uint64_t &framenumber, uint32_t &packetnumber,uint32_t &subframenumber){ +int UDPStandardImplementation::getFrameandPacketNumber(int ithread, char* wbuffer, uint64_t &framenumber, uint32_t &packetnumber,uint32_t &subframenumber, uint64_t &bunchid){ FILE_LOG(logDEBUG) << __AT__ << " called"; eiger_packet_footer_t* footer=0; @@ -3410,6 +3302,7 @@ int UDPStandardImplementation::getFrameandPacketNumber(int ithread, char* wbuffe framenumber = 0; packetnumber = 0; subframenumber = 0; + bunchid = 0; switch(myDetectorType){ @@ -3417,7 +3310,7 @@ int UDPStandardImplementation::getFrameandPacketNumber(int ithread, char* wbuffe footer = (eiger_packet_footer_t*)(wbuffer + footerOffset); framenumber = (uint32_t)(*( (uint64_t*) footer)); //error in frame number sent by fpga - if(!((uint32_t)(*( (uint64_t*) footer)))){ + if(((uint32_t)(*( (uint64_t*) footer)))==0){ framenumber = 0; FILE_LOG(logERROR) << "Fifo "<< ithread << ": Frame Number is zero from firmware."; return FAIL; @@ -3434,19 +3327,21 @@ int UDPStandardImplementation::getFrameandPacketNumber(int ithread, char* wbuffe subframenumber, footerOffset); #endif - framenumber += (startFrameIndex - 1); + framenumber -= startFrameIndex; break; case JUNGFRAU: header = (jfrau_packet_header_t*)(wbuffer); framenumber = (*( (uint32_t*) header->frameNumber))&frameIndexMask; packetnumber = (uint32_t)(*( (uint8_t*) header->packetNumber)); + bunchid = (*((uint64_t*) header->bunchid)); #ifdef DEBUG4 - cprintf(GREEN, "Writing_Thread %d: fnum:%lld\t pnum:%d\n", + cprintf(GREEN, "Writing_Thread %d: fnum:%lld\t pnum:%d bunchid:%lld\n", (long long int)framenumber, - packetnumber); + packetnumber, + (long long int)bunchid); #endif - framenumber += startFrameIndex; + framenumber -= startFrameIndex; break; default: @@ -3461,7 +3356,7 @@ int UDPStandardImplementation::getFrameandPacketNumber(int ithread, char* wbuffe (long long int)framenumber, packetnumber); #endif - framenumber += startFrameIndex; + framenumber -= startFrameIndex; break; } return OK; @@ -3482,8 +3377,9 @@ int UDPStandardImplementation::writeUptoFrameNumber(int ithread, char* wbuffer, offset = endoffset; uint32_t pnum; uint32_t snum; + uint64_t bunchid=-1; //get last frame number - if(getFrameandPacketNumber(ithread, wbuffer + (endoffset-onePacketSize), tempframenumber,pnum,snum) == FAIL){ + if(getFrameandPacketNumber(ithread, wbuffer + (endoffset-onePacketSize), tempframenumber,pnum,snum,bunchid) == FAIL){ //error in frame number sent by fpga while(!fifoFree[ithread]->push(wbuffer)); return FAIL; @@ -3509,7 +3405,7 @@ int UDPStandardImplementation::writeUptoFrameNumber(int ithread, char* wbuffer, offset -= bigIncrements; if(offsetpush(wbuffer)); return FAIL; @@ -3517,7 +3413,7 @@ int UDPStandardImplementation::writeUptoFrameNumber(int ithread, char* wbuffer, } if(offsetpush(wbuffer)); return FAIL; @@ -3525,7 +3421,7 @@ int UDPStandardImplementation::writeUptoFrameNumber(int ithread, char* wbuffer, } while(tempframenumberpush(wbuffer)); return FAIL; diff --git a/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp b/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp index 4507726ad..db4e91a33 100644 --- a/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp +++ b/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp @@ -24,7 +24,7 @@ using namespace std; slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() { stop(); - if(socket) {delete socket; socket=NULL;} + if(mySock) {delete mySock; mySock=NULL;} } slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int &success, UDPInterface* rbase, int pn, bool bot): @@ -39,7 +39,7 @@ slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int &success, UDPInterface* tenGigaEnable(0), portNumber(DEFAULT_PORTNO+2), bottom(bot), - socket(NULL){ + mySock(NULL){ strcpy(SET_RECEIVER_ERR_MESSAGE,"Receiver not set up. Please use rx_hostname first.\n"); @@ -51,7 +51,7 @@ slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int &success, UDPInterface* rawDataReadyCallBack = NULL; pRawDataReady = NULL; - int port_no=portNumber; + unsigned short int port_no=portNumber; if(receiverBase == NULL) receiverBase = 0; if (pn>0) @@ -61,16 +61,16 @@ slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int &success, UDPInterface* //create socket if(success == OK){ - socket = new MySocketTCP(port_no); - if (socket->getErrorStatus()) { + mySock = new MySocketTCP(port_no); + if (mySock->getErrorStatus()) { success = FAIL; - delete socket; - socket=NULL; + delete mySock; + mySock=NULL; } else { portNumber=port_no; //initialize variables - strcpy(socket->lastClientIP,"none"); - strcpy(socket->thisClientIP,"none1"); + strcpy(mySock->lastClientIP,"none"); + strcpy(mySock->thisClientIP,"none1"); strcpy(mess,"dummy message"); function_table(); #ifdef VERYVERBOSE @@ -96,13 +96,13 @@ int slsReceiverTCPIPInterface::setPortNumber(int pn){ cout << mess << endl; } else { - oldsocket=socket; - socket = new MySocketTCP(p_number); - if(socket){ - sd = socket->getErrorStatus(); + oldsocket=mySock; + mySock = new MySocketTCP(p_number); + if(mySock){ + sd = mySock->getErrorStatus(); if (!sd){ portNumber=p_number; - strcpy(socket->lastClientIP,oldsocket->lastClientIP); + strcpy(mySock->lastClientIP,oldsocket->lastClientIP); delete oldsocket; } else { cout << "Could not bind port " << p_number << endl; @@ -110,13 +110,13 @@ int slsReceiverTCPIPInterface::setPortNumber(int pn){ cout << "Port "<< p_number << " already set" << endl; } else { - delete socket; - socket=oldsocket; + delete mySock; + mySock=oldsocket; } } } else { - socket=oldsocket; + mySock=oldsocket; } } } @@ -143,7 +143,7 @@ int slsReceiverTCPIPInterface::start(){ void slsReceiverTCPIPInterface::stop(){ cout << "Shutting down UDP Socket" << endl; killTCPServerThread = 1; - if(socket) socket->ShutDownSocket(); + if(mySock) mySock->ShutDownSocket(); cout<<"Socket closed"<Connect()>=0){ + if(mySock->Connect()>=0){ #ifdef VERY_VERBOSE cout << "Conenction accepted" << endl; #endif @@ -183,7 +183,7 @@ void slsReceiverTCPIPInterface::startTCPServer(){ #ifdef VERY_VERBOSE cout << "function executed" << endl; #endif - socket->Disconnect(); + mySock->Disconnect(); #ifdef VERY_VERBOSE cout << "connection closed" << endl; #endif @@ -199,7 +199,7 @@ void slsReceiverTCPIPInterface::startTCPServer(){ receiverBase->closeFile(); } - socket->exitServer(); + mySock->exitServer(); pthread_exit(NULL); } @@ -285,7 +285,7 @@ int slsReceiverTCPIPInterface::decode_function(){ #ifdef VERYVERBOSE cout << "receive data" << endl; #endif - n = socket->ReceiveDataOnly(&fnum,sizeof(fnum)); + n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum)); if (n <= 0) { #ifdef VERYVERBOSE cout << "ERROR reading from socket " << n << ", " << fnum << endl; @@ -322,8 +322,8 @@ int slsReceiverTCPIPInterface::M_nofunc(){ sprintf(mess,"Unrecognized Function\n"); cout << mess << endl; - socket->SendDataOnly(&ret,sizeof(ret)); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(mess,sizeof(mess)); return GOODBYE; } @@ -344,7 +344,7 @@ int slsReceiverTCPIPInterface::set_detector_type(){ // receive arguments - if(socket->ReceiveDataOnly(&dr,sizeof(dr)) < 0 ){ + if(mySock->ReceiveDataOnly(&dr,sizeof(dr)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -352,8 +352,8 @@ int slsReceiverTCPIPInterface::set_detector_type(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if((receiverBase)&&(receiverBase->getStatus()==RUNNING || receiverBase->getStatus()==TRANSMITTING)){ @@ -405,16 +405,16 @@ int slsReceiverTCPIPInterface::set_detector_type(){ //#endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL) - socket->SendDataOnly(mess,sizeof(mess)); - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -434,7 +434,7 @@ int slsReceiverTCPIPInterface::set_file_name() { strcpy(mess,"Could not set file name"); // receive arguments - if(socket->ReceiveDataOnly(fName,MAX_STR_LENGTH) < 0 ){ + if(mySock->ReceiveDataOnly(fName,MAX_STR_LENGTH) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -443,8 +443,8 @@ int slsReceiverTCPIPInterface::set_file_name() { #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -471,21 +471,21 @@ int slsReceiverTCPIPInterface::set_file_name() { #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } if(retval == NULL) - socket->SendDataOnly(defaultVal,MAX_STR_LENGTH); + mySock->SendDataOnly(defaultVal,MAX_STR_LENGTH); else{ - socket->SendDataOnly(retval,MAX_STR_LENGTH); + mySock->SendDataOnly(retval,MAX_STR_LENGTH); delete[] retval; } @@ -507,7 +507,7 @@ int slsReceiverTCPIPInterface::set_file_dir() { strcpy(mess,"Could not set file path\n"); // receive arguments - if(socket->ReceiveDataOnly(fPath,MAX_STR_LENGTH) < 0 ){ + if(mySock->ReceiveDataOnly(fPath,MAX_STR_LENGTH) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -515,8 +515,8 @@ int slsReceiverTCPIPInterface::set_file_dir() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -545,21 +545,21 @@ int slsReceiverTCPIPInterface::set_file_dir() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } if(retval == NULL) - socket->SendDataOnly(defaultVal,MAX_STR_LENGTH); + mySock->SendDataOnly(defaultVal,MAX_STR_LENGTH); else{ - socket->SendDataOnly(retval,MAX_STR_LENGTH); + mySock->SendDataOnly(retval,MAX_STR_LENGTH); delete[] retval; } @@ -580,7 +580,7 @@ int slsReceiverTCPIPInterface::set_file_index() { // receive arguments - if(socket->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -588,8 +588,8 @@ int slsReceiverTCPIPInterface::set_file_index() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -616,18 +616,18 @@ int slsReceiverTCPIPInterface::set_file_index() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -648,7 +648,7 @@ int slsReceiverTCPIPInterface::set_frame_index() { // receive arguments - if(socket->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -656,8 +656,8 @@ int slsReceiverTCPIPInterface::set_frame_index() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -693,18 +693,18 @@ int slsReceiverTCPIPInterface::set_frame_index() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -729,7 +729,7 @@ int slsReceiverTCPIPInterface::setup_udp(){ // receive arguments - if(socket->ReceiveDataOnly(args,sizeof(args)) < 0 ){ + if(mySock->ReceiveDataOnly(args,sizeof(args)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -737,8 +737,8 @@ int slsReceiverTCPIPInterface::setup_udp(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -790,18 +790,18 @@ int slsReceiverTCPIPInterface::setup_udp(){ } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ FILE_LOG(logERROR) << mess; - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(retval,MAX_STR_LENGTH); + mySock->SendDataOnly(retval,MAX_STR_LENGTH); //return ok/fail return ret; @@ -820,8 +820,8 @@ int slsReceiverTCPIPInterface::start_receiver(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } /* @@ -845,16 +845,16 @@ int slsReceiverTCPIPInterface::start_receiver(){ } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "Error:%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } //return ok/fail return ret; @@ -870,8 +870,8 @@ int slsReceiverTCPIPInterface::stop_receiver(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -892,16 +892,16 @@ int slsReceiverTCPIPInterface::stop_receiver(){ } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } //return ok/fail return ret; @@ -923,19 +923,19 @@ int slsReceiverTCPIPInterface::get_status(){ }else s=receiverBase->getStatus(); #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } retval = (runStatus(s)); - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -954,18 +954,18 @@ int slsReceiverTCPIPInterface::get_frames_caught(){ ret=FAIL; }else retval=receiverBase->getTotalFramesCaught(); #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -986,18 +986,18 @@ int slsReceiverTCPIPInterface::get_frame_index(){ retval=receiverBase->getAcquisitionIndex(); #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -1014,8 +1014,8 @@ int slsReceiverTCPIPInterface::reset_frames_caught(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -1031,16 +1031,16 @@ int slsReceiverTCPIPInterface::reset_frames_caught(){ } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } //return ok/fail return ret; @@ -1066,7 +1066,7 @@ int slsReceiverTCPIPInterface::set_short_frame() { } // receive arguments - if(socket->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -1075,8 +1075,8 @@ int slsReceiverTCPIPInterface::set_short_frame() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -1099,18 +1099,18 @@ int slsReceiverTCPIPInterface::set_short_frame() { } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -1281,22 +1281,22 @@ int slsReceiverTCPIPInterface::moench_read_frame(){ #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } else{ - socket->SendDataOnly(fName,MAX_STR_LENGTH); - socket->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); - socket->SendDataOnly(&frameIndex,sizeof(frameIndex)); - socket->SendDataOnly(retval,MOENCH_DATA_BYTES); + mySock->SendDataOnly(fName,MAX_STR_LENGTH); + mySock->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); + mySock->SendDataOnly(&frameIndex,sizeof(frameIndex)); + mySock->SendDataOnly(retval,MOENCH_DATA_BYTES); } //return ok/fail @@ -1462,22 +1462,22 @@ int slsReceiverTCPIPInterface::gotthard_read_frame(){ #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } else{ - socket->SendDataOnly(fName,MAX_STR_LENGTH); - socket->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); - socket->SendDataOnly(&frameIndex,sizeof(frameIndex)); - socket->SendDataOnly(retval,GOTTHARD_DATA_BYTES); + mySock->SendDataOnly(fName,MAX_STR_LENGTH); + mySock->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); + mySock->SendDataOnly(&frameIndex,sizeof(frameIndex)); + mySock->SendDataOnly(retval,GOTTHARD_DATA_BYTES); } delete [] retval; @@ -1616,22 +1616,22 @@ int slsReceiverTCPIPInterface::propix_read_frame(){ #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } else{ - socket->SendDataOnly(fName,MAX_STR_LENGTH); - socket->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); - socket->SendDataOnly(&frameIndex,sizeof(frameIndex)); - socket->SendDataOnly(retval,PROPIX_DATA_BYTES); + mySock->SendDataOnly(fName,MAX_STR_LENGTH); + mySock->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); + mySock->SendDataOnly(&frameIndex,sizeof(frameIndex)); + mySock->SendDataOnly(retval,PROPIX_DATA_BYTES); } delete [] retval; @@ -1670,8 +1670,8 @@ int slsReceiverTCPIPInterface::eiger_read_frame(){ onePacketSize = EIGER_TEN_GIGA_ONE_PACKET_SIZE; } char* raw; - char* origVal = new char[frameSize]; - char* retval = new char[dataSize]; + char* origVal = new char[frameSize](); + char* retval = new char[dataSize](); memset(origVal,0xFF,frameSize); memset(retval,0xFF,dataSize); @@ -1883,23 +1883,23 @@ int slsReceiverTCPIPInterface::eiger_read_frame(){ #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } else{ - socket->SendDataOnly(fName,MAX_STR_LENGTH); - socket->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); - socket->SendDataOnly(&frameIndex,sizeof(frameIndex)); - socket->SendDataOnly(&subframenumber,sizeof(subframenumber)); - socket->SendDataOnly(retval,dataSize); + mySock->SendDataOnly(fName,MAX_STR_LENGTH); + mySock->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); + mySock->SendDataOnly(&frameIndex,sizeof(frameIndex)); + mySock->SendDataOnly(&subframenumber,sizeof(subframenumber)); + mySock->SendDataOnly(retval,dataSize); } delete [] retval; @@ -1932,9 +1932,9 @@ int slsReceiverTCPIPInterface::jungfrau_read_frame(){ int oneDataSize = JFRAU_ONE_DATA_SIZE; char* raw; - char* origVal = new char[frameSize]; - char* retval = new char[dataSize]; - char* blackpacket = new char[oneDataSize]; + char* origVal = new char[frameSize](); + char* retval = new char[dataSize](); + char* blackpacket = new char[oneDataSize](); for(int i=0;idifferentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } else{ - socket->SendDataOnly(fName,MAX_STR_LENGTH); - socket->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); - socket->SendDataOnly(&frameIndex,sizeof(frameIndex)); - socket->SendDataOnly(retval,dataSize); + mySock->SendDataOnly(fName,MAX_STR_LENGTH); + mySock->SendDataOnly(&acquisitionIndex,sizeof(acquisitionIndex)); + mySock->SendDataOnly(&frameIndex,sizeof(frameIndex)); + mySock->SendDataOnly(retval,dataSize); } delete [] retval; @@ -2084,7 +2084,7 @@ int slsReceiverTCPIPInterface::set_read_frequency(){ // receive arguments - if(socket->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2092,8 +2092,8 @@ int slsReceiverTCPIPInterface::set_read_frequency(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2124,18 +2124,18 @@ int slsReceiverTCPIPInterface::set_read_frequency(){ #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2154,7 +2154,7 @@ int slsReceiverTCPIPInterface::set_read_receiver_timer(){ // receive arguments - if(socket->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2162,8 +2162,8 @@ int slsReceiverTCPIPInterface::set_read_receiver_timer(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2190,18 +2190,18 @@ int slsReceiverTCPIPInterface::set_read_receiver_timer(){ #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2218,7 +2218,7 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){ // receive arguments - if(socket->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2226,8 +2226,8 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2253,18 +2253,18 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){ #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2282,7 +2282,7 @@ int slsReceiverTCPIPInterface::enable_file_write(){ // receive arguments - if(socket->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){ + if(mySock->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2290,8 +2290,8 @@ int slsReceiverTCPIPInterface::enable_file_write(){ // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2312,18 +2312,18 @@ int slsReceiverTCPIPInterface::enable_file_write(){ } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2340,14 +2340,14 @@ int slsReceiverTCPIPInterface::get_id(){ retval = getReceiverVersion(); #endif - if(socket->differentClients){ + if(mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2388,18 +2388,18 @@ int slsReceiverTCPIPInterface::start_readout(){cprintf(BLUE,"In start readout!\n } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2418,7 +2418,7 @@ int slsReceiverTCPIPInterface::set_timer() { // receive arguments - if(socket->ReceiveDataOnly(index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2426,8 +2426,8 @@ int slsReceiverTCPIPInterface::set_timer() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2475,18 +2475,18 @@ int slsReceiverTCPIPInterface::set_timer() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2504,7 +2504,7 @@ int slsReceiverTCPIPInterface::enable_compression() { strcpy(mess,"Could not enable/disable compression for receiver\n"); // receive arguments - if(socket->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){ + if(mySock->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2514,8 +2514,8 @@ int slsReceiverTCPIPInterface::enable_compression() { #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { if(enable >= 0){ - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2546,18 +2546,18 @@ int slsReceiverTCPIPInterface::enable_compression() { } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2574,7 +2574,7 @@ int slsReceiverTCPIPInterface::set_detector_hostname() { strcpy(mess,"Could not set detector hostname"); // receive arguments - if(socket->ReceiveDataOnly(hostname,MAX_STR_LENGTH) < 0 ){ + if(mySock->ReceiveDataOnly(hostname,MAX_STR_LENGTH) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2583,8 +2583,8 @@ int slsReceiverTCPIPInterface::set_detector_hostname() { #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2611,21 +2611,21 @@ int slsReceiverTCPIPInterface::set_detector_hostname() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED, "%s\n", mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } if(retval == NULL) - socket->SendDataOnly(defaultVal,MAX_STR_LENGTH); + mySock->SendDataOnly(defaultVal,MAX_STR_LENGTH); else{ - socket->SendDataOnly(retval,MAX_STR_LENGTH); + mySock->SendDataOnly(retval,MAX_STR_LENGTH); delete[] retval; } @@ -2647,7 +2647,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range() { // receive arguments - if(socket->ReceiveDataOnly(&dr,sizeof(dr)) < 0 ){ + if(mySock->ReceiveDataOnly(&dr,sizeof(dr)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2655,8 +2655,8 @@ int slsReceiverTCPIPInterface::set_dynamic_range() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (dr>0) { @@ -2711,18 +2711,18 @@ int slsReceiverTCPIPInterface::set_dynamic_range() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2742,7 +2742,7 @@ int slsReceiverTCPIPInterface::enable_overwrite() { // receive arguments - if(socket->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ + if(mySock->ReceiveDataOnly(&index,sizeof(index)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2750,8 +2750,8 @@ int slsReceiverTCPIPInterface::enable_overwrite() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2778,18 +2778,18 @@ int slsReceiverTCPIPInterface::enable_overwrite() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2809,7 +2809,7 @@ int slsReceiverTCPIPInterface::enable_tengiga() { // receive arguments - if(socket->ReceiveDataOnly(&val,sizeof(val)) < 0 ){ + if(mySock->ReceiveDataOnly(&val,sizeof(val)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2817,8 +2817,8 @@ int slsReceiverTCPIPInterface::enable_tengiga() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2847,18 +2847,18 @@ int slsReceiverTCPIPInterface::enable_tengiga() { #endif #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2876,7 +2876,7 @@ int slsReceiverTCPIPInterface::set_fifo_depth() { strcpy(mess,"Could not set/get fifo depth for receiver\n"); // receive arguments - if(socket->ReceiveDataOnly(&value,sizeof(value)) < 0 ){ + if(mySock->ReceiveDataOnly(&value,sizeof(value)) < 0 ){ strcpy(mess,"Error reading from socket\n"); ret = FAIL; } @@ -2886,8 +2886,8 @@ int slsReceiverTCPIPInterface::set_fifo_depth() { #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { if(value >= 0){ - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } else if (receiverBase == NULL){ @@ -2918,18 +2918,18 @@ int slsReceiverTCPIPInterface::set_fifo_depth() { } #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -2947,7 +2947,7 @@ int slsReceiverTCPIPInterface::set_activate() { // receive arguments - if(socket->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){ + if(mySock->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){ strcpy(mess,"Error reading from socket\n"); cprintf(RED,"%s",mess); ret = FAIL; @@ -2957,8 +2957,8 @@ int slsReceiverTCPIPInterface::set_activate() { // execute action if the arguments correctly arrived #ifdef SLS_RECEIVER_UDP_FUNCTIONS if (ret==OK) { - if (lockStatus==1 && socket->differentClients==1){ - sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1){ + sprintf(mess,"Receiver locked by %s\n", mySock->lastClientIP); ret=FAIL; } @@ -2992,18 +2992,18 @@ int slsReceiverTCPIPInterface::set_activate() { #endif - if(ret==OK && socket->differentClients){ + if(ret==OK && mySock->differentClients){ FILE_LOG(logDEBUG) << "Force update"; ret=FORCE_UPDATE; } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } - socket->SendDataOnly(&retval,sizeof(retval)); + mySock->SendDataOnly(&retval,sizeof(retval)); //return ok/fail return ret; @@ -3045,7 +3045,7 @@ int slsReceiverTCPIPInterface::lock_receiver() { int lock; // receive arguments - if(socket->ReceiveDataOnly(&lock,sizeof(lock)) < 0 ){ + if(mySock->ReceiveDataOnly(&lock,sizeof(lock)) < 0 ){ sprintf(mess,"Error reading from socket\n"); cout << "Error reading from socket (lock)" << endl; ret=FAIL; @@ -3053,27 +3053,27 @@ int slsReceiverTCPIPInterface::lock_receiver() { // execute action if the arguments correctly arrived if(ret==OK){ if (lock>=0) { - if (lockStatus==0 || strcmp(socket->lastClientIP,socket->thisClientIP)==0 || strcmp(socket->lastClientIP,"none")==0) { + if (lockStatus==0 || strcmp(mySock->lastClientIP,mySock->thisClientIP)==0 || strcmp(mySock->lastClientIP,"none")==0) { lockStatus=lock; - strcpy(socket->lastClientIP,socket->thisClientIP); + strcpy(mySock->lastClientIP,mySock->thisClientIP); } else { ret=FAIL; - sprintf(mess,"Receiver already locked by %s\n", socket->lastClientIP); + sprintf(mess,"Receiver already locked by %s\n", mySock->lastClientIP); } } } - if (socket->differentClients && ret==OK) + if (mySock->differentClients && ret==OK) ret=FORCE_UPDATE; // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); } else - socket->SendDataOnly(&lockStatus,sizeof(lockStatus)); + mySock->SendDataOnly(&lockStatus,sizeof(lockStatus)); //return ok/fail return ret; @@ -3094,13 +3094,13 @@ int slsReceiverTCPIPInterface::set_port() { int p_number; // receive arguments - if(socket->ReceiveDataOnly(&p_type,sizeof(p_type)) < 0 ){ + if(mySock->ReceiveDataOnly(&p_type,sizeof(p_type)) < 0 ){ strcpy(mess,"Error reading from socket\n"); cout << mess << endl; ret=FAIL; } - if(socket->ReceiveDataOnly(&p_number,sizeof(p_number)) < 0 ){ + if(mySock->ReceiveDataOnly(&p_number,sizeof(p_number)) < 0 ){ strcpy(mess,"Error reading from socket\n"); cout << mess << endl; ret=FAIL; @@ -3108,9 +3108,9 @@ int slsReceiverTCPIPInterface::set_port() { // execute action if the arguments correctly arrived if (ret==OK) { - if (socket->differentClients==1 && lockStatus==1 ) { + if (mySock->differentClients==1 && lockStatus==1 ) { ret=FAIL; - sprintf(mess,"Detector locked by %s\n",socket->lastClientIP); + sprintf(mess,"Detector locked by %s\n",mySock->lastClientIP); } else { if (p_number<1024) { @@ -3119,14 +3119,14 @@ int slsReceiverTCPIPInterface::set_port() { ret=FAIL; } cout << "set port " << p_type << " to " << p_number <lastClientIP); + strcpy(oldLastClientIP, mySock->lastClientIP); mySocket = new MySocketTCP(p_number); } if(mySocket){ sd = mySocket->getErrorStatus(); if (!sd){ ret=OK; - strcpy(socket->lastClientIP,oldLastClientIP); + strcpy(mySock->lastClientIP,oldLastClientIP); if (mySocket->differentClients) ret=FORCE_UPDATE; } else { @@ -3142,16 +3142,16 @@ int slsReceiverTCPIPInterface::set_port() { } // send answer - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); }else { - socket->SendDataOnly(&p_number,sizeof(p_number)); + mySock->SendDataOnly(&p_number,sizeof(p_number)); if(sd>=0){ - socket->Disconnect(); - delete socket; - socket = mySocket; + mySock->Disconnect(); + delete mySock; + mySock = mySocket; } } @@ -3167,11 +3167,11 @@ int slsReceiverTCPIPInterface::set_port() { int slsReceiverTCPIPInterface::get_last_client_ip() { ret=OK; - if (socket->differentClients ) + if (mySock->differentClients ) ret=FORCE_UPDATE; - socket->SendDataOnly(&ret,sizeof(ret)); - socket->SendDataOnly(socket->lastClientIP,sizeof(socket->lastClientIP)); + mySock->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(mySock->lastClientIP,sizeof(mySock->lastClientIP)); return ret; } @@ -3188,14 +3188,14 @@ int slsReceiverTCPIPInterface::send_update() { char defaultVal[MAX_STR_LENGTH]=""; char* path = NULL; - socket->SendDataOnly(socket->lastClientIP,sizeof(socket->lastClientIP)); + mySock->SendDataOnly(mySock->lastClientIP,sizeof(mySock->lastClientIP)); //index #ifdef SLS_RECEIVER_UDP_FUNCTIONS ind=receiverBase->getFileIndex(); - socket->SendDataOnly(&ind,sizeof(ind)); + mySock->SendDataOnly(&ind,sizeof(ind)); #endif //filepath @@ -3203,9 +3203,9 @@ int slsReceiverTCPIPInterface::send_update() { path = receiverBase->getFilePath(); #endif if(path == NULL) - socket->SendDataOnly(defaultVal,MAX_STR_LENGTH); + mySock->SendDataOnly(defaultVal,MAX_STR_LENGTH); else{ - socket->SendDataOnly(path,MAX_STR_LENGTH); + mySock->SendDataOnly(path,MAX_STR_LENGTH); delete[] path; } @@ -3215,14 +3215,14 @@ int slsReceiverTCPIPInterface::send_update() { path = receiverBase->getFileName(); #endif if(path == NULL) - socket->SendDataOnly(defaultVal,MAX_STR_LENGTH); + mySock->SendDataOnly(defaultVal,MAX_STR_LENGTH); else{ - socket->SendDataOnly(path,MAX_STR_LENGTH); + mySock->SendDataOnly(path,MAX_STR_LENGTH); delete[] path; } if (lockStatus==0) { - strcpy(socket->lastClientIP,socket->thisClientIP); + strcpy(mySock->lastClientIP,mySock->thisClientIP); } return ret; @@ -3241,10 +3241,10 @@ int slsReceiverTCPIPInterface::update_client() { strcpy(mess,SET_RECEIVER_ERR_MESSAGE); ret=FAIL; } - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); if(ret==FAIL){ cprintf(RED,"%s\n",mess); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); return ret; } @@ -3259,9 +3259,9 @@ int slsReceiverTCPIPInterface::update_client() { int slsReceiverTCPIPInterface::exit_server() { ret=GOODBYE; - socket->SendDataOnly(&ret,sizeof(ret)); + mySock->SendDataOnly(&ret,sizeof(ret)); strcpy(mess,"closing server"); - socket->SendDataOnly(mess,sizeof(mess)); + mySock->SendDataOnly(mess,sizeof(mess)); cprintf(RED,"%s\n",mess); return ret; } @@ -3277,7 +3277,7 @@ int slsReceiverTCPIPInterface::exec_command() { int sysret=0; // receive arguments - if(socket->ReceiveDataOnly(cmd,MAX_STR_LENGTH) < 0 ){ + if(mySock->ReceiveDataOnly(cmd,MAX_STR_LENGTH) < 0 ){ sprintf(mess,"Error reading from socket\n"); ret=FAIL; } @@ -3287,14 +3287,14 @@ int slsReceiverTCPIPInterface::exec_command() { #ifdef VERYVERBOSE cout << "executing command " << cmd << endl; #endif - if (lockStatus==0 || socket->differentClients==0) + if (lockStatus==0 || mySock->differentClients==0) sysret=system(cmd); //should be replaced by popen if (sysret==0) { strcpy(answer,"Succeeded\n"); - if (lockStatus==1 && socket->differentClients==1) - sprintf(answer,"Detector locked by %s\n", socket->lastClientIP); + if (lockStatus==1 && mySock->differentClients==1) + sprintf(answer,"Detector locked by %s\n", mySock->lastClientIP); } else { strcpy(answer,"Failed\n"); ret=FAIL; @@ -3304,8 +3304,8 @@ int slsReceiverTCPIPInterface::exec_command() { // send answer - socket->SendDataOnly(&ret,sizeof(ret)); - if(socket->SendDataOnly(answer,MAX_STR_LENGTH) < 0){ + mySock->SendDataOnly(&ret,sizeof(ret)); + if(mySock->SendDataOnly(answer,MAX_STR_LENGTH) < 0){ strcpy(mess,"Error writing to socket"); ret=FAIL; }