mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-22 03:40:04 +02:00
e2f9d69677
git-svn-id: file:///afs/psi.ch/project/sls_det_software/svn/slsDetectorSoftware@1 951219d9-93cf-4727-9268-0efd64621fa3
517 lines
11 KiB
C
Executable File
517 lines
11 KiB
C
Executable File
|
|
|
|
#include "communication_funcs.h"
|
|
//#include <sys/socket.h>
|
|
#include <netinet/tcp.h> /* for TCP_NODELAY */
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
//int socketDescriptor, file_des;
|
|
int socketDescriptor, file_des;
|
|
const int send_rec_max_size=SEND_REC_MAX_SIZE;
|
|
extern int errno;
|
|
|
|
//struct sockaddr_in address;
|
|
//#define VERY_VERBOSE
|
|
|
|
|
|
int bindSocket(unsigned short int port_number) {
|
|
int i;
|
|
|
|
struct sockaddr_in addressS;
|
|
|
|
|
|
file_des= -1;
|
|
socketDescriptor = socket(AF_INET, SOCK_STREAM,0); //tcp
|
|
|
|
//socketDescriptor = socket(PF_INET, SOCK_STREAM, 0);
|
|
|
|
|
|
|
|
if (socketDescriptor < 0) {
|
|
printf("Can not create socket\n");
|
|
} else {
|
|
|
|
i = 1;
|
|
setsockopt(socketDescriptor, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
|
|
// setsockopt(socketDescriptor, IPPROTO_TCP, TCP_NODELAY, (char *) &i, sizeof(i));
|
|
// TCP_CORK
|
|
|
|
// Set some fields in the serverAddress structure.
|
|
addressS.sin_family = AF_INET;
|
|
addressS.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
addressS.sin_port = htons(port_number);
|
|
|
|
// memset(&address.sin_addr, 0, sizeof(address.sin_addr));
|
|
|
|
|
|
if(bind(socketDescriptor,(struct sockaddr *) &addressS,sizeof(addressS))<0){
|
|
|
|
printf("Can not create socket\n");
|
|
|
|
socketDescriptor=-1;
|
|
} else {
|
|
listen(socketDescriptor, 5);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//int getrlimit(int resource, struct rlimit *rlim);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return socketDescriptor;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
only client funcs
|
|
*/
|
|
/*
|
|
#ifndef C_ONLY
|
|
|
|
MySocketTCP::MySocketTCP(const char* const host_ip_or_name, unsigned short int const port_number):
|
|
last_keep_connection_open_action_was_a_send(0), file_des(-1), send_rec_max_size(SEND_REC_MAX_SIZE), is_a_server(0), portno(DEFAULT_PORTNO), socketDescriptor(-1)
|
|
{ // sender (client): where to? ip
|
|
//is_a_server = 0;
|
|
// SetupParameters();
|
|
strcpy(hostname,host_ip_or_name);
|
|
portno=port_number;
|
|
struct hostent *hostInfo = gethostbyname(host_ip_or_name);
|
|
if (hostInfo == NULL){
|
|
cerr << "Exiting: Problem interpreting host: " << host_ip_or_name << "\n";
|
|
} else {
|
|
// Set some fields in the serverAddress structure.
|
|
serverAddress.sin_family = hostInfo->h_addrtype;
|
|
memcpy((char *) &serverAddress.sin_addr.s_addr,
|
|
hostInfo->h_addr_list[0], hostInfo->h_length);
|
|
serverAddress.sin_port = htons(port_number);
|
|
socketDescriptor=0; //You can use send and recv, //would it work?????
|
|
}
|
|
}
|
|
|
|
|
|
int MySocketTCP::getHostname(char *name) {
|
|
if (is_a_server==0) {
|
|
strcpy(name,hostname);
|
|
}
|
|
return is_a_server;
|
|
};
|
|
#endif
|
|
*/
|
|
|
|
|
|
|
|
|
|
int getServerError()
|
|
{
|
|
if (socketDescriptor<0) return 1;
|
|
else return 0;
|
|
};
|
|
|
|
|
|
int acceptConnection() {
|
|
struct sockaddr_in addressC;
|
|
//socklen_t address_length;
|
|
size_t address_length=sizeof(struct sockaddr_in);
|
|
|
|
if(file_des>0) return file_des;
|
|
|
|
|
|
#ifndef C_ONLY
|
|
if(is_a_server){ //server; the server will wait for the clients connection
|
|
#endif
|
|
|
|
|
|
if (socketDescriptor>0) {
|
|
//if ((file_des = accept(socketDescriptor,(struct sockaddr *) &address, &address_length)) < 0) {
|
|
if ((file_des = accept(socketDescriptor,(struct sockaddr *) &addressC, &address_length)) < 0) {
|
|
|
|
|
|
printf("Error: with server accept, connection refused %d\n", errno);
|
|
|
|
|
|
switch(errno) {
|
|
case EWOULDBLOCK:
|
|
printf("ewouldblock eagain\n");
|
|
break;
|
|
case EBADF:
|
|
printf("ebadf\n");
|
|
break;
|
|
case ECONNABORTED:
|
|
printf("econnaborted\n");
|
|
break;
|
|
case EFAULT:
|
|
printf("efault\n");
|
|
break;
|
|
case EINTR:
|
|
printf("eintr\n");
|
|
break;
|
|
case EINVAL:
|
|
printf("einval\n");
|
|
break;
|
|
case EMFILE:
|
|
printf("emfile\n");
|
|
break;
|
|
case ENFILE:
|
|
printf("enfile\n");
|
|
break;
|
|
case ENOTSOCK:
|
|
printf("enotsock\n");
|
|
break;
|
|
case EOPNOTSUPP:
|
|
printf("eOPNOTSUPP\n");
|
|
break;
|
|
case ENOBUFS:
|
|
printf("ENOBUFS\n");
|
|
break;
|
|
case ENOMEM:
|
|
printf("ENOMEM\n");
|
|
break;
|
|
case ENOSR:
|
|
printf("ENOSR\n");
|
|
break;
|
|
case EPROTO:
|
|
printf("EPROTO\n");
|
|
break;
|
|
default:
|
|
printf("unknown error\n");
|
|
}
|
|
|
|
|
|
socketDescriptor=-1;
|
|
}
|
|
#ifdef VERY_VERBOSE
|
|
printf("client connected %d\n", file_des);
|
|
#endif
|
|
}
|
|
|
|
|
|
return file_des;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void closeConnection() {
|
|
//fflush(stdout);
|
|
//printf("Closing file_des %d\n", file_des);
|
|
//sleep(1);
|
|
#ifdef VERY_VERBOSE
|
|
#endif
|
|
if(file_des>=0)
|
|
close(file_des);
|
|
file_des=-1;
|
|
}
|
|
|
|
void exitServer() {
|
|
if (socketDescriptor>=0)
|
|
close(socketDescriptor);
|
|
#ifdef VERY_VERBOSE
|
|
printf("Closing server\n");
|
|
#endif
|
|
socketDescriptor=-1;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* client close conenction */
|
|
/*
|
|
#ifndef C_ONLY
|
|
void MySocketTCP::Disconnect(){
|
|
|
|
if(file_des>=0){ //then was open
|
|
if(is_a_server){
|
|
close(file_des);
|
|
}
|
|
else {
|
|
close(socketDescriptor);
|
|
socketDescriptor=-1;
|
|
}
|
|
file_des=-1;
|
|
}
|
|
|
|
}
|
|
#endif
|
|
*/
|
|
|
|
|
|
int sendDataOnly(void* buf,int length) {
|
|
/*
|
|
int total_sent=0;
|
|
int nsending;
|
|
int nsent;
|
|
|
|
|
|
#ifdef VERY_VERBOSE
|
|
printf("want to send %d Bytes\n", length);
|
|
#endif
|
|
if (file_des<0) return -1;
|
|
|
|
while(length>0){
|
|
nsending = (length>send_rec_max_size) ? send_rec_max_size:length;
|
|
nsent = write(file_des,(char*)buf+total_sent,nsending);
|
|
if(!nsent) break;
|
|
length-=nsent;
|
|
total_sent+=nsent;
|
|
// cout<<"nsent: "<<nsent<<endl;
|
|
}
|
|
*/
|
|
|
|
|
|
return write(file_des, buf, length);
|
|
#ifdef VERBOSE
|
|
// printf("sent %d Bytes\n", total_sent);
|
|
#endif
|
|
}
|
|
|
|
|
|
int receiveDataOnly(void* buf,int length) {
|
|
|
|
int total_received=0;
|
|
int nreceiving;
|
|
int nreceived;
|
|
if (file_des<0) return -1;
|
|
#ifdef VERY_VERBOSE
|
|
printf("want to receive %d Bytes\n", length);
|
|
#endif
|
|
|
|
while(length>0){
|
|
nreceiving = (length>send_rec_max_size) ? send_rec_max_size:length;
|
|
nreceived = read(file_des,(char*)buf+total_received,nreceiving);
|
|
if(!nreceived) break;
|
|
length-=nreceived;
|
|
total_received+=nreceived;
|
|
// cout<<"nrec: "<<nreceived<<" waiting for ("<<length<<")"<<endl;
|
|
}
|
|
|
|
#ifdef VERY_VERBOSE
|
|
printf("received %d Bytes\n", total_received);
|
|
#endif
|
|
|
|
return total_received;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int sendChannel(sls_detector_channel *myChan) {
|
|
return sendDataOnly(myChan, sizeof(sls_detector_channel));
|
|
}
|
|
|
|
int sendChip(sls_detector_chip *myChip) {
|
|
int ts=0;
|
|
int nChans=myChip->nchan;
|
|
ts+=sendDataOnly(myChip,sizeof(sls_detector_chip));
|
|
ts+=sendDataOnly(myChip->chanregs,nChans*sizeof(int));
|
|
return ts;
|
|
}
|
|
|
|
int sendModule(sls_detector_module *myMod) {
|
|
int ts=0;
|
|
int nChips=myMod->nchip;
|
|
int nChans=myMod->nchan;
|
|
int nAdcs=myMod->nadc;
|
|
int nDacs=myMod->ndac;
|
|
ts+= sendDataOnly(myMod,sizeof(sls_detector_module));
|
|
ts+= sendDataOnly(myMod->dacs,sizeof(float)*nDacs);
|
|
ts+= sendDataOnly(myMod->adcs,sizeof(float)*nAdcs);
|
|
ts+=sendDataOnly(myMod->chipregs,sizeof(int)*nChips);
|
|
ts+=sendDataOnly(myMod->chanregs,sizeof(int)*nChans);
|
|
#ifdef VERBOSE
|
|
printf("module %d of size %d sent register %x\n",myMod->module, ts, myMod->reg);
|
|
#endif
|
|
return ts;
|
|
}
|
|
|
|
int receiveChannel(sls_detector_channel *myChan) {
|
|
return receiveDataOnly(myChan,sizeof(sls_detector_channel));
|
|
}
|
|
|
|
int receiveChip(sls_detector_chip* myChip) {
|
|
|
|
int *ptr=myChip->chanregs;
|
|
int ts=0;
|
|
int nChans, nchanold=myChip->nchan, chdiff;
|
|
|
|
ts+= receiveDataOnly(myChip,sizeof(sls_detector_chip));
|
|
|
|
|
|
myChip->chanregs=ptr;
|
|
nChans=myChip->nchan;
|
|
chdiff=nChans-nchanold;
|
|
if (nchanold!=nChans) {
|
|
printf("wrong number of channels received!\n");
|
|
}
|
|
|
|
|
|
#ifdef VERBOSE
|
|
printf("chip structure received\n");
|
|
printf("now receiving %d channels\n", nChans);
|
|
#endif
|
|
|
|
if (chdiff<=0)
|
|
ts+=receiveDataOnly(myChip->chanregs, sizeof(int)*nChans);
|
|
else {
|
|
ptr=malloc(chdiff*sizeof(int));
|
|
myChip->nchan=nchanold;
|
|
ts+=receiveDataOnly(myChip->chanregs, sizeof(int)*nchanold);
|
|
ts+=receiveDataOnly(ptr, sizeof(int)*chdiff);
|
|
free(ptr);
|
|
return FAIL;
|
|
}
|
|
|
|
#ifdef VERBOSE
|
|
printf("chip's channels received\n");
|
|
#endif
|
|
return ts;
|
|
}
|
|
|
|
int receiveModule(sls_detector_module* myMod) {
|
|
|
|
|
|
float *dacptr=myMod->dacs;
|
|
float *adcptr=myMod->adcs;
|
|
int *chipptr=myMod->chipregs, *chanptr=myMod->chanregs;
|
|
int ts=0;
|
|
int nChips, nchipold=myMod->nchip, nchipdiff;
|
|
int nChans, nchanold=myMod->nchan, nchandiff;
|
|
int nDacs, ndold=myMod->ndac, ndacdiff;
|
|
int nAdcs, naold=myMod->nadc, nadcdiff;
|
|
|
|
|
|
ts+= receiveDataOnly(myMod,sizeof(sls_detector_module));
|
|
|
|
myMod->dacs=dacptr;
|
|
myMod->adcs=adcptr;
|
|
myMod->chipregs=chipptr;
|
|
myMod->chanregs=chanptr;
|
|
|
|
nChips=myMod->nchip;
|
|
nchipdiff=nChips-nchipold;
|
|
if (nchipold!=nChips) {
|
|
printf("received wrong number of chips\n");
|
|
}
|
|
#ifdef VERBOSE
|
|
else
|
|
printf("received %d chips\n",nChips);
|
|
#endif
|
|
|
|
nChans=myMod->nchan;
|
|
nchandiff=nChans-nchanold;
|
|
if (nchanold!=nChans) {
|
|
printf("received wrong number of channels\n");
|
|
}
|
|
#ifdef VERBOSE
|
|
else
|
|
printf("received %d chans\n",nChans);
|
|
#endif
|
|
|
|
|
|
nDacs=myMod->ndac;
|
|
ndacdiff=nDacs-ndold;
|
|
if (ndold!=nDacs) {
|
|
printf("received wrong number of dacs\n");
|
|
}
|
|
#ifdef VERBOSE
|
|
else
|
|
printf("received %d dacs\n",nDacs);
|
|
#endif
|
|
|
|
nAdcs=myMod->nadc;
|
|
nadcdiff=nAdcs-naold;
|
|
if (naold!=nAdcs) {
|
|
printf("received wrong number of adcs\n");
|
|
}
|
|
#ifdef VERBOSE
|
|
else
|
|
printf("received %d adcs\n",nAdcs);
|
|
#endif
|
|
if (ndacdiff<=0) {
|
|
ts+=receiveDataOnly(myMod->dacs, sizeof(float)*nDacs);
|
|
#ifdef VERBOSE
|
|
printf("dacs received\n");
|
|
#endif
|
|
} else {
|
|
dacptr=malloc(ndacdiff*sizeof(float));
|
|
myMod->ndac=ndold;
|
|
ts+=receiveDataOnly(myMod->dacs, sizeof(float)*ndold);
|
|
ts+=receiveDataOnly(dacptr, sizeof(float)*ndacdiff);
|
|
free(dacptr);
|
|
return FAIL;
|
|
}
|
|
|
|
if (nadcdiff<=0) {
|
|
ts+=receiveDataOnly(myMod->adcs, sizeof(float)*nAdcs);
|
|
#ifdef VERBOSE
|
|
printf("adcs received\n");
|
|
#endif
|
|
} else {
|
|
adcptr=malloc(nadcdiff*sizeof(float));
|
|
myMod->nadc=naold;
|
|
ts+=receiveDataOnly(myMod->adcs, sizeof(float)*naold);
|
|
ts+=receiveDataOnly(adcptr, sizeof(float)*nadcdiff);
|
|
free(adcptr);
|
|
return FAIL;
|
|
}
|
|
|
|
if (nchipdiff<=0) {
|
|
ts+=receiveDataOnly(myMod->chipregs, sizeof(int)*nChips);
|
|
#ifdef VERBOSE
|
|
printf("chips received\n");
|
|
#endif
|
|
} else {
|
|
chipptr=malloc(nchipdiff*sizeof(int));
|
|
myMod->nchip=nchipold;
|
|
ts+=receiveDataOnly(myMod->chipregs, sizeof(int)*nchipold);
|
|
ts+=receiveDataOnly(chipptr, sizeof(int)*nchipdiff);
|
|
free(chipptr);
|
|
return FAIL;
|
|
}
|
|
|
|
if (nchandiff<=0) {
|
|
ts+=receiveDataOnly(myMod->chanregs, sizeof(int)*nChans);
|
|
#ifdef VERBOSE
|
|
printf("chans received\n");
|
|
#endif
|
|
} else {
|
|
chanptr=malloc(nchandiff*sizeof(int));
|
|
myMod->nchan=nchanold;
|
|
ts+=receiveDataOnly(myMod->chanregs, sizeof(int)*nchanold);
|
|
ts+=receiveDataOnly(chanptr, sizeof(int)*nchandiff);
|
|
free(chanptr);
|
|
return FAIL;
|
|
}
|
|
#ifdef VERBOSE
|
|
printf("received module %d of size %d register %x\n",myMod->module,ts,myMod->reg);
|
|
#endif
|
|
return ts;
|
|
}
|