int sendRawWaveformPackets(int bufSize)
{
static int errorCounter=0;
int retVal;
if(bufSize!=sizeof(AnitaEventBody_t)) {
if(errorCounter<100) {
syslog(LOG_ERR,"Buffer size %d, expected %u -- Bailing\n",bufSize,(unsigned int)sizeof(AnitaEventBody_t));
fprintf(stderr,"Buffer size %d, expected %u -- Bailing\n",bufSize,(unsigned int)sizeof(AnitaEventBody_t));
errorCounter++;
}
return -1;
}
AnitaEventBody_t *bdPtr = (AnitaEventBody_t*) theBuffer;
int chan;
RawWaveformPacket_t *wvPtr;
for(chan=0;chan<NUM_DIGITZED_CHANNELS;chan++) {
wvPtr=(RawWaveformPacket_t*) chanBuffer;
wvPtr->eventNumber=bdPtr->eventNumber;
memcpy(&(wvPtr->waveform),&(bdPtr->channel[chan]),sizeof(SurfChannelFull_t));
wvPtr->gHdr.packetNumber=getOpenportNumber();
fillGenericHeader(wvPtr,PACKET_WV,sizeof(RawWaveformPacket_t));
retVal = openportWrite(chanBuffer,sizeof(RawWaveformPacket_t),0);
eventDataSent+=sizeof(RawWaveformPacket_t);
if(retVal<0) {
//Problem sending data
if(errorCounter<100) {
syslog(LOG_ERR,"Problem sending event %u over OPENPORT high rate\n",bdPtr->eventNumber);
errorCounter++;
}
fprintf(stderr,"Problem sending event %u over OPENPORT high rate \n",bdPtr->eventNumber);
}
}
return retVal;
}
int sendRawSurfPackets(int bufSize)
{
static int errorCounter=0;
int retVal;
if(bufSize!=sizeof(AnitaEventBody_t)) {
if(errorCounter<100) {
syslog(LOG_ERR,"Buffer size %d, expected %u -- Bailing\n",bufSize,(unsigned int)sizeof(AnitaEventBody_t));
fprintf(stderr,"Buffer size %d, expected %u -- Bailing\n",bufSize,(unsigned int)sizeof(AnitaEventBody_t));
errorCounter++;
}
return -1;
}
AnitaEventBody_t *bdPtr = (AnitaEventBody_t*) theBuffer;
int surf;
RawSurfPacket_t *surfPtr;
for(surf=0;surf<ACTIVE_SURFS;surf++) {
surfPtr=(RawSurfPacket_t*) chanBuffer;
surfPtr->eventNumber=bdPtr->eventNumber;
memcpy(&(surfPtr->waveform[0]),&(bdPtr->channel[CHANNELS_PER_SURF*surf]),sizeof(SurfChannelFull_t)*CHANNELS_PER_SURF);
surfPtr->gHdr.packetNumber=getOpenportNumber();
fillGenericHeader(surfPtr,PACKET_SURF,sizeof(RawSurfPacket_t));
retVal = openportWrite(chanBuffer,sizeof(RawSurfPacket_t),0);
eventDataSent+=sizeof(RawSurfPacket_t);
if(retVal<0) {
//Problem sending data
if(errorCounter<100) {
syslog(LOG_ERR,"Problem sending event %u over Openport\n",bdPtr->eventNumber);
errorCounter++;
}
fprintf(stderr,"Problem sending event %u over Openport\n",bdPtr->eventNumber);
}
}
return retVal;
}
int sendEncodedPedSubbedSurfPackets(int bufSize)
{
static int errorCounter=0;
EncodedPedSubbedSurfPacketHeader_t *surfHdPtr;
int numBytes,count=0,surf=0,retVal;
// Remember what the file contains is actually 9 EncodedPedSubbedSurfPacketHeader_t's
// count=0;
count=sizeof(EncodedEventWrapper_t);
for(surf=0;surf<ACTIVE_SURFS;surf++) {
surfHdPtr = (EncodedPedSubbedSurfPacketHeader_t*) &theBuffer[count];
surfHdPtr->gHdr.packetNumber=getOpenportNumber();
numBytes = surfHdPtr->gHdr.numBytes;
if(numBytes) {
retVal = openportWrite(&theBuffer[count],numBytes,0);
if(retVal<0) {
//Problem sending data
if(errorCounter<100) {
syslog(LOG_ERR,"Problem sending event %u over OPENPORT high rate \n",surfHdPtr->eventNumber);
errorCounter++;
}
fprintf(stderr,"Problem sending event %u over OPENPORT high rate \n",surfHdPtr->eventNumber);
}
count+=numBytes;
eventDataSent+=numBytes;
}
else break;
if(count>bufSize) return -1;
}
return 0;
}
int sendEncodedPedSubbedWavePackets(int bufSize)
{
static int errorCounter=0;
EncodedPedSubbedChannelPacketHeader_t *waveHdPtr;
EncodedPedSubbedSurfPacketHeader_t *surfHdPtr;
EncodedSurfChannelHeader_t *chanHdPtr;
EncodedSurfChannelHeader_t *chanHdPtr2;
int numBytes,count=0,surf=0,retVal,chan,count2=0;
int chanNumBytes=0;
// Remember what the file contains is actually 10 EncodedPedSubbedSurfPacketHeader_t's
// count=0;
count=sizeof(EncodedEventWrapper_t);
for(surf=0;surf<ACTIVE_SURFS;surf++) {
surfHdPtr = (EncodedPedSubbedSurfPacketHeader_t*) &theBuffer[count];
// surfHdPtr->gHdr.packetNumber=getOpenportNumber();
numBytes = surfHdPtr->gHdr.numBytes;
count2=count+sizeof(EncodedPedSubbedSurfPacketHeader_t);
if(numBytes) {
for(chan=0;chan<CHANNELS_PER_SURF;chan++) {
chanNumBytes=0;
chanHdPtr = (EncodedSurfChannelHeader_t*) &theBuffer[count2];
waveHdPtr= (EncodedPedSubbedChannelPacketHeader_t*) &chanBuffer[0];
waveHdPtr->gHdr.packetNumber=getOpenportNumber();
waveHdPtr->eventNumber=surfHdPtr->eventNumber;
waveHdPtr->whichPeds=surfHdPtr->whichPeds;
chanNumBytes=sizeof(EncodedPedSubbedChannelPacketHeader_t);
chanHdPtr2 = (EncodedSurfChannelHeader_t*) &chanBuffer[chanNumBytes];
(*chanHdPtr2)=(*chanHdPtr);
count2+=sizeof(EncodedSurfChannelHeader_t);
chanNumBytes+=sizeof(EncodedSurfChannelHeader_t);
memcpy(&chanBuffer[chanNumBytes],&theBuffer[count2],chanHdPtr->numBytes);
chanNumBytes+=chanHdPtr->numBytes;
fillGenericHeader(waveHdPtr,PACKET_ENC_WV_PEDSUB,chanNumBytes);
retVal = openportWrite(chanBuffer,chanNumBytes,0);
eventDataSent+=chanNumBytes;
if(retVal<0) {
//Problem sending data
if(errorCounter<100) {
syslog(LOG_ERR,"Problem sending event %u over OPENPORT high rate \n",surfHdPtr->eventNumber);
errorCounter++;
}
fprintf(stderr,"Problem sending event %u over OPENPORT high rate \n",surfHdPtr->eventNumber);
}
}
count+=numBytes;
}
else break;
if(count>bufSize) return -1;
}
return 0;
}
int readAndSendEventRamdisk(char *headerLinkFilename) {
static int errorCounter=0;
AnitaEventHeader_t *theHeader;
GenericHeader_t *gHdr;
int retVal;
char currentTouchname[FILENAME_MAX];
char currentLOSTouchname[FILENAME_MAX];
char waveFilename[FILENAME_MAX];
char headerFilename[FILENAME_MAX];
// char crapBuffer[FILENAME_MAX];
char justFile[FILENAME_MAX];
unsigned int thisEventNumber;
//First up we test if the link still exists
if(!checkFileExists(headerLinkFilename))
return 0;
retVal=snprintf(justFile,sizeof(justFile),"%s",basename(headerLinkFilename));
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=sscanf(justFile,"hd_%u.dat",&thisEventNumber);
if(retVal<=0) {
syslog(LOG_ERR,"Error reading eventNumber from %s",justFile);
thisEventNumber=0;
}
if(thisEventNumber==0) {
printf("Why is this zero -- %s\n",headerLinkFilename);
}
retVal=snprintf(headerFilename,sizeof(headerFilename),"%s/hd_%d.dat",eventTelemDirs[currentPri],thisEventNumber);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(waveFilename,sizeof(waveFilename),"%s/hd_%d.dat",eventTelemDirs[currentPri], thisEventNumber);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentTouchname,sizeof(currentTouchname),"%s.sipd",headerFilename);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentLOSTouchname,sizeof(currentLOSTouchname),"%s.losd",headerFilename);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
if(checkFileExists(currentLOSTouchname))
return 0;
touchFile(currentTouchname);
// printf("%s\n",headerLinkFilename);
removeFile(headerLinkFilename);
// Next load header
theHeader=(AnitaEventHeader_t*) &theBuffer[0];
retVal=fillHeader(theHeader,headerFilename);
if(retVal<0) {
// syslog(LOG_ERR,"Problem with %s",headerFilename);
retVal=snprintf(headerFilename,sizeof(headerFilename),"%s/hd_%d.dat",eventTelemDirs[currentPri],thisEventNumber);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
unlink(currentTouchname);
unlink(headerFilename);
unlink(waveFilename);
//Bollocks
return 0;
}
theHeader->gHdr.packetNumber=getOpenportNumber();
retVal = openportWrite((unsigned char*)theHeader,sizeof(AnitaEventHeader_t),0);
if(retVal<0) {
//Problem sending data
syslog(LOG_ERR,"Problem sending file %s over Openport\n",headerFilename);
fprintf(stderr,"Problem sending file %s over Openport\n",headerFilename);
}
eventDataSent+=sizeof(AnitaEventHeader_t);
thisEventNumber=theHeader->eventNumber;
//Now get event file
retVal=snprintf(headerFilename,sizeof(headerFilename),"%s/hd_%d.dat",eventTelemDirs[currentPri], thisEventNumber);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(waveFilename,sizeof(waveFilename),"%s/ev_%d.dat",eventTelemDirs[currentPri], thisEventNumber);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=genericReadOfFile((unsigned char*)theBuffer,waveFilename,MAX_EVENT_SIZE);
if(retVal<0) {
fprintf(stderr,"Problem reading %s\n",waveFilename);
syslog(LOG_ERR,"Problem reading %s\n",waveFilename);
// unlink(headerLinkFilename);
unlink(headerFilename);
unlink(waveFilename);
unlink(currentTouchname);
//Bollocks
return 0;
}
//Okay so now the buffer either contains EncodedSurfPacketHeader_t or
// it contains EncodedPedSubbedSurfPacketHeader_t
gHdr = (GenericHeader_t*) &theBuffer[0];
switch(gHdr->code) {
case PACKET_BD:
if(sendWavePackets)
retVal=sendRawWaveformPackets(retVal);
else
retVal=sendRawSurfPackets(retVal);
break;
case PACKET_PED_SUBBED_EVENT:
if(sendWavePackets)
retVal=sendPedSubbedWaveformPackets(retVal);
else
retVal=sendPedSubbedSurfPackets(retVal);
break;
case PACKET_ENC_EVENT_WRAPPER:
retVal=sendEncodedSurfPackets(retVal);
break;
case PACKET_ENC_PEDSUB_EVENT_WRAPPER:
if(!sendWavePackets) {
retVal=sendEncodedPedSubbedSurfPackets(retVal);
}
else {
retVal=sendEncodedPedSubbedWavePackets(retVal);
}
break;
default:
if(errorCounter<100) {
syslog(LOG_ERR,"Don't know what to do with packet %d -- %s (Message %d of 100)\n",gHdr->code,packetCodeAsString(gHdr->code),errorCounter);
errorCounter++;
}
fprintf(stderr,"Don't know what to do with packet %d -- %s\n",gHdr->code,packetCodeAsString(gHdr->code));
}
if(printToScreen && verbosity>1)
printf("Removing files %s\t%s\n%s\n",headerFilename,waveFilename,
headerLinkFilename);
if(!checkFileExists(currentLOSTouchname)) {
// unlink(headerLinkFilename);
unlink(headerFilename);
unlink(waveFilename);
unlink(currentTouchname);
}
else {
sleep(1);
// unlink(headerLinkFilename);
unlink(headerFilename);
unlink(waveFilename);
unlink(currentTouchname);
unlink(currentLOSTouchname);
}
return 1;
}
int readHkAndOpenport(int wd,int maxCopy, char *telemDir, char *linkDir, int fileSize, int *numSent)
/* Looks in the specified directroy and OPENPORT's up to maxCopy bytes of data */
/* fileSize is the maximum size of a packet in the directory */
{
// fprintf(stderr,"readHkAndOpenport %s -- %d\n",linkDir,maxCopy);
char currentFilename[FILENAME_MAX];
char currentTouchname[FILENAME_MAX];
char currentLOSTouchname[FILENAME_MAX];
char currentLinkname[FILENAME_MAX];
int retVal,numLinks,count,numBytes,totalBytes=0;//,checkVal=0;
char *tempString;
GenericHeader_t *gHdr;
*numSent=0;
numLinks=getNumLinks(wd);
if(numLinks<=0) {
return 0;
}
int counter=0;
for(count=numLinks-1;count>=0;count--) {
//Get last link name
tempString=getLastLink(wd);
retVal=snprintf(currentFilename,sizeof(currentFilename),"%s/%s",telemDir,tempString);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentTouchname,sizeof(currentTouchname),"%s.sipd",currentFilename);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentLOSTouchname,sizeof(currentLOSTouchname),"%s.losd",currentFilename);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentLinkname,sizeof(currentLinkname),"%s/%s",linkDir,tempString);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
if(!checkFileExists(currentLinkname))
continue;
if(checkFileExists(currentLOSTouchname))
continue;
touchFile(currentTouchname);
if(checkFileExists(currentLOSTouchname)) {
unlink(currentTouchname);
continue;
}
retVal=genericReadOfFile((unsigned char*)theBuffer,
currentFilename,
MAX_EVENT_SIZE);
syslog(LOG_DEBUG,"Trying %s",currentFilename);
if(retVal<=0) {
// syslog(LOG_ERR,"Error opening file, will delete: %s",
// currentFilename);
// fprintf(stderr,"Error reading file %s -- %d\n",currentFilename,retVal);
unlink(currentFilename);
unlink(currentLinkname);
unlink(currentTouchname);
continue;
}
numBytes=retVal;
if(printToScreen && verbosity>=0) {
printf("Read File: %s -- (%d bytes)\n",currentFilename,numBytes);
}
// printf("Read %d bytes from file\n",numBytes);
// Maybe I'll add a packet check here
gHdr = (GenericHeader_t*)theBuffer;
// checkVal=checkPacket(gHdr);
// if(checkVal!=0 ) {
// printf("Bad packet %s == %d\n",currentFilename,checkVal);
// }
gHdr->packetNumber=getOpenportNumber();
printf("Openport number %d\n",gHdr->packetNumber);
retVal = openportWrite(theBuffer, numBytes,1);
if(retVal<0) {
//Problem sending data
syslog(LOG_ERR,"Problem sending Wake up Packet over OPENPORT\n");
fprintf(stderr,"Problem sending Wake up Packet over OPENPORT\n");
}
totalBytes+=numBytes;
if(!checkFileExists(currentLOSTouchname)) {
unlink(currentLinkname);
unlink(currentFilename);
unlink(currentTouchname);
}
else {
usleep(1);
unlink(currentLinkname);
unlink(currentFilename);
unlink(currentTouchname);
unlink(currentLOSTouchname);
}
(*numSent)++;
// if((totalBytes+fileSize)>maxCopy) break;
counter++;
if(counter>=maxCopy) break;
// break;
}
// fprintf(stderr,"readHkAndOpenport %s -- %d\n",linkDir,*numSent);
return totalBytes;
}
int checkLinkDirAndOpenport(int maxCopy, char *telemDir, char *linkDir, int fileSize)
/* Looks in the specified directroy and OPENPORT's up to maxCopy bytes of data */
/* fileSize is the maximum size of a packet in the directory */
{
char currentFilename[FILENAME_MAX];
char currentTouchname[FILENAME_MAX];
char currentLOSTouchname[FILENAME_MAX];
char currentLinkname[FILENAME_MAX];
int retVal,numLinks,count,numBytes,totalBytes=0;//,checkVal=0;
GenericHeader_t *gHdr;
struct dirent **linkList;
numLinks=getListofLinks(linkDir,&linkList);
if(numLinks<=0) {
return 0;
}
int counter=0;
for(count=numLinks-1;count>=0;count--) {
retVal=snprintf(currentFilename,sizeof(currentFilename),"%s/%s",telemDir,
linkList[count]->d_name);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentTouchname,sizeof(currentTouchname),"%s.sipd",currentFilename);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentLOSTouchname,sizeof(currentLOSTouchname),"%s.losd",currentFilename);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(currentLinkname,sizeof(currentLinkname),"%s/%s",
linkDir,linkList[count]->d_name);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
if(checkFileExists(currentLOSTouchname))
continue;
touchFile(currentTouchname);
retVal=genericReadOfFile((unsigned char*)theBuffer,
currentFilename,
MAX_EVENT_SIZE);
syslog(LOG_DEBUG,"Trying %s",currentFilename);
if(retVal<=0) {
// syslog(LOG_ERR,"Error opening file, will delete: %s",
// currentFilename);
// fprintf(stderr,"Error reading file %s -- %d\n",currentFilename,retVal);
removeFile(currentFilename);
removeFile(currentLinkname);
removeFile(currentTouchname);
continue;
}
numBytes=retVal;
if(printToScreen && verbosity>1) {
printf("Read File: %s -- (%d bytes)\n",currentFilename,numBytes);
}
printf("Read %d bytes from file\n",numBytes);
// Maybe I'll add a packet check here
gHdr = (GenericHeader_t*)theBuffer;
// checkVal=checkPacket(gHdr);
// if(checkVal!=0 ) {
// printf("Bad packet %s == %d\n",currentFilename,checkVal);
// }
gHdr->packetNumber=getOpenportNumber();
printf("Openport number %d\n",gHdr->packetNumber);
retVal = openportWrite(theBuffer, numBytes,1);
if(retVal<0) {
//Problem sending data
syslog(LOG_ERR,"Problem sending Wake up Packet over Openprt\n");
fprintf(stderr,"Problem sending Wake up Packet over Openport\n");
}
totalBytes+=numBytes;
if(!checkFileExists(currentLOSTouchname)) {
removeFile(currentLinkname);
removeFile(currentFilename);
removeFile(currentTouchname);
}
else {
sleep(1);
removeFile(currentLinkname);
removeFile(currentFilename);
removeFile(currentTouchname);
removeFile(currentLOSTouchname);
}
printf("Got code: %#x %#x\n",gHdr->code&BASE_PACKET_MASK,PACKET_GPS_ADU5_PAT);
// if((totalBytes+fileSize)>maxCopy) break;
counter++;
if(counter>=maxCopy) break;
// break;
}
for(count=0;count<numLinks;count++)
free(linkList[count]);
free(linkList);
return totalBytes;
}
