feudp.cxx File Reference

#include <stdio.h>
#include <netdb.h>
#include <string.h>
#include <errno.h>
#include <string>
#include <vector>
#include "midas.h"
#include "mfe.h"
#include "mstrlcpy.h"
#include <sys/time.h>

Include dependency graph for feudp.cxx:

Go to the source code of this file.

Classes
struct	Source

Macros
#define	EQ_NAME   "UDP"
#define	EQ_EVID   1
#define	MAX_UDP_SIZE   (0x10000)

Functions
int	interrupt_configure (INT cmd, INT source, PTYPE adr)
INT	poll_event (INT source, INT count, BOOL test)
int	frontend_init ()
	Frontend initialization.
int	frontend_exit ()
	Frontend exit.
int	begin_of_run (int run, char *err)
	Begin of Run.
int	end_of_run (int run, char *err)
	End of Run.
int	pause_run (int run, char *err)
	Pause Run.
int	resume_run (int run, char *err)
	Resume Run.
int	frontend_loop ()
	Frontend loop.
int	read_event (char *pevent, INT off)
static double	GetTimeSec ()
int	open_udp_socket (int server_port)
bool	addr_match (const Source *s, void *addr, int addr_len)
int	wait_udp (int socket, int msec)
int	find_source (Source *src, const sockaddr *paddr, int addr_len)
int	read_udp (int socket, char *buf, int bufsize, char *pbankname)

Variables
const char *	frontend_name = "feudp"
const char *	frontend_file_name = __FILE__
BOOL	frontend_call_loop = TRUE
int	display_period = 0
int	max_event_size = 1*1024*1024
int	max_event_size_frag = 5 * 1024 * 1024
int	event_buffer_size = 8*1024*1024
BOOL	equipment_common_overwrite = FALSE
EQUIPMENT	equipment []
static std::vector< Source >	gSrc
static HNDLE	hKeySet
static int	gDataSocket
static int	gUnknownPacketCount = 0
static bool	gSkipUnknownPackets = false

Macro Definition Documentation

EQ_EVID

#define EQ_EVID   1

Definition at line 47 of file feudp.cxx.

EQ_NAME

#define EQ_NAME   "UDP"

Definition at line 43 of file feudp.cxx.

MAX_UDP_SIZE

#define MAX_UDP_SIZE   (0x10000)

Definition at line 401 of file feudp.cxx.

Function Documentation

addr_match()

bool addr_match	(	const Source *	s,
		void *	addr,
		int	addr_len
	)

Definition at line 150 of file feudp.cxx.

{
  int v = memcmp(&s->addr, addr, addr_len);
#if 0
  for (int i=0; i<addr_len; i++)
    printf("%3d - 0x%02x 0x%02x\n", i, ((char*)&s->addr)[i], ((char*)addr)[i]);
  printf("match %d, hostname [%s] bank [%s], status %d\n", addr_len, s->host_name.c_str(), s->bank_name, v);
#endif
  return v==0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

begin_of_run()

int begin_of_run	(	int	run,
		char *	err
	)

Begin of Run.

Called every run start transition. Set equipment status in ODB, start acquisition on the modules.

Parameters

[in]	run_number	Number of the run being started
[out]	error	Can be used to write a message string to midas.log

Definition at line 361 of file feudp.cxx.

{
   gUnknownPacketCount = 0;
   gSkipUnknownPackets = false;
   return SUCCESS;
}

end_of_run()

int end_of_run	(	int	run,
		char *	err
	)

End of Run.

Called every stop run transition. Set equipment status in ODB, stop acquisition on the modules.

Parameters

[in]	run_number	Number of the run being ended
[out]	error	Can be used to write a message string to midas.log

Definition at line 368 of file feudp.cxx.

{
   return SUCCESS;
}

find_source()

int find_source	(	Source *	src,
		const sockaddr *	paddr,
		int	addr_len
	)

Definition at line 198 of file feudp.cxx.

{
   char host[NI_MAXHOST], service[NI_MAXSERV];
      
   int status = getnameinfo(paddr, addr_len, host, NI_MAXHOST, service, NI_MAXSERV, NI_NUMERICSERV);
      
   if (status != 0) {
      cm_msg(MERROR, "read_udp", "getnameinfo() returned %d (%s), errno %d (%s)", status, gai_strerror(status), errno, strerror(errno));
      return -1;
   }
 
   char bankname[NAME_LENGTH];
   int size = sizeof(bankname);
      
   status = db_get_value(hDB, hKeySet, host, bankname, &size, TID_STRING, FALSE);
   
   if (status == DB_NO_KEY) {
      cm_msg(MERROR, "read_udp", "UDP packet from unknown host \"%s\"", host);
      cm_msg(MINFO, "read_udp", "Register this host by running following commands:");
      cm_msg(MINFO, "read_udp", "odbedit -c \"create STRING /Equipment/%s/Settings/%s\"", EQ_NAME, host);
      cm_msg(MINFO, "read_udp", "odbedit -c \"set /Equipment/%s/Settings/%s AAAA\", where AAAA is the MIDAS bank name for this host", EQ_NAME, host);
      return -1;
   } else if (status != DB_SUCCESS) {
      cm_msg(MERROR, "read_udp", "db_get_value(\"/Equipment/%s/Settings/%s\") status %d", EQ_NAME, host, status);
      return -1;
   }
 
   if (strlen(bankname) != 4) {
      cm_msg(MERROR, "read_udp", "ODB \"/Equipment/%s/Settings/%s\" should be set to a 4 character MIDAS bank name", EQ_NAME, host);
      cm_msg(MINFO, "read_udp", "Use this command:");
      cm_msg(MINFO, "read_udp", "odbedit -c \"set /Equipment/%s/Settings/%s AAAA\", where AAAA is the MIDAS bank name for this host", EQ_NAME, host);
      return -1;
   }
      
   cm_msg(MINFO, "read_udp", "UDP packets from host \"%s\" will be stored in bank \"%s\"", host, bankname);
      
   src->host_name = host;
   mstrlcpy(src->bank_name, bankname, 5);
   memcpy(&src->addr, paddr, sizeof(src->addr));
   
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

frontend_exit()

int frontend_exit

(

void

)

Frontend exit.

Runs at frontend shutdown. Disconnect hardware and set equipment status in ODB

Returns

Midas status code

Definition at line 383 of file feudp.cxx.

{
   return SUCCESS;
}

frontend_init()

int frontend_init

(

void

)

Frontend initialization.

Runs once at application startup. We initialize the hardware and optical interfaces and set the equipment status in ODB. We also lock the frontend to once physical cpu core.

Returns

Midas status code

Definition at line 309 of file feudp.cxx.

{
   int status;
 
   status = cm_get_experiment_database(&hDB, NULL);
   if (status != CM_SUCCESS) {
      cm_msg(MERROR, "frontend_init", "Cannot connect to ODB, cm_get_experiment_database() returned %d", status);
      return FE_ERR_ODB;
   }
 
   std::string path;
   path += "/Equipment";
   path += "/";
   path += EQ_NAME;
   path += "/Settings";
 
   std::string path1 = path + "/udp_port";
 
   int udp_port = 50005;
   int size = sizeof(udp_port);
   status = db_get_value(hDB, 0, path1.c_str(), &udp_port, &size, TID_INT, TRUE);
   
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "frontend_init", "Cannot find \"%s\", db_get_value() returned %d", path1.c_str(), status);
      return FE_ERR_ODB;
   }
   
   status = db_find_key(hDB, 0, path.c_str(), &hKeySet);
   
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "frontend_init", "Cannot find \"%s\", db_find_key() returned %d", path.c_str(), status);
      return FE_ERR_ODB;
   }
   
   gDataSocket = open_udp_socket(udp_port);
   
   if (gDataSocket < 0) {
      printf("frontend_init: cannot open udp socket\n");
      cm_msg(MERROR, "frontend_init", "Cannot open UDP socket for port %d", udp_port);
      return FE_ERR_HW;
   }
 
   cm_msg(MINFO, "frontend_init", "Frontend equipment \"%s\" is ready, listening on UDP port %d", EQ_NAME, udp_port);
   return SUCCESS;
}

Here is the call graph for this function:

frontend_loop()

int frontend_loop

(

void

)

Frontend loop.

If frontend_call_loop is true, this routine gets called when the frontend is idle or once between every event.

Returns

Midas status code

Definition at line 355 of file feudp.cxx.

{
   ss_sleep(10);
   return SUCCESS;
}

Here is the call graph for this function:

GetTimeSec()

static double GetTimeSec ( )

static

Definition at line 66 of file feudp.cxx.

{
   struct timeval tv;
   gettimeofday(&tv,NULL);
   return tv.tv_sec + 0.000001*tv.tv_usec;
}

Here is the call graph for this function:

Here is the caller graph for this function:

interrupt_configure()

int interrupt_configure	(	INT	cmd,
		INT	source,
		PTYPE	adr
	)

Definition at line 304 of file feudp.cxx.

{
   return SUCCESS;
}

open_udp_socket()

int open_udp_socket

(

int

server_port

)

Definition at line 90 of file feudp.cxx.

{
   int status;
   
   int fd = socket(AF_INET, SOCK_DGRAM, 0);
   
   if (fd < 0) {
      cm_msg(MERROR, "open_udp_socket", "socket(AF_INET,SOCK_DGRAM) returned %d, errno %d (%s)", fd, errno, strerror(errno));
      return -1;
   }
 
   int opt = 1;
   status = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
   if (status == -1) {
      cm_msg(MERROR, "open_udp_socket", "setsockopt(SOL_SOCKET,SO_REUSEADDR) returned %d, errno %d (%s)", status, errno, strerror(errno));
      return -1;
   }
 
   int bufsize = 8*1024*1024;
   //int bufsize = 20*1024;
 
   status = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
 
   if (status == -1) {
      cm_msg(MERROR, "open_udp_socket", "setsockopt(SOL_SOCKET,SO_RCVBUF) returned %d, errno %d (%s)", status, errno, strerror(errno));
      return -1;
   }
 
   struct sockaddr_in local_addr;
   memset(&local_addr, 0, sizeof(local_addr));
 
   local_addr.sin_family = AF_INET;
   local_addr.sin_port = htons(server_port);
   local_addr.sin_addr.s_addr = INADDR_ANY;
 
   status = bind(fd, (struct sockaddr *)&local_addr, sizeof(local_addr));
 
   if (status == -1) {
      cm_msg(MERROR, "open_udp_socket", "bind(port=%d) returned %d, errno %d (%s)", server_port, status, errno, strerror(errno));
      return -1;
   }
 
   int xbufsize = 0;
   unsigned size = sizeof(xbufsize);
 
   status = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &xbufsize, &size);
 
   //printf("status %d, xbufsize %d, size %d\n", status, xbufsize, size);
 
   if (status == -1) {
      cm_msg(MERROR, "open_udp_socket", "getsockopt(SOL_SOCKET,SO_RCVBUF) returned %d, errno %d (%s)", status, errno, strerror(errno));
      return -1;
   }
 
   cm_msg(MINFO, "open_udp_socket", "UDP port %d socket receive buffer size is %d", server_port, xbufsize);
 
   return fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pause_run()

int pause_run	(	int	run,
		char *	err
	)

Pause Run.

Called every pause run transition.

Parameters

[in]	run_number	Number of the run being ended
[out]	error	Can be used to write a message string to midas.log

Returns

Midas status code

Definition at line 373 of file feudp.cxx.

{
   return SUCCESS;
}

poll_event()

INT poll_event	(	INT	source,
		INT	count,
		BOOL	test
	)

Definition at line 388 of file feudp.cxx.

{
   //printf("poll_event: source %d, count %d, test %d\n", source, count, test);
 
   if (test) {
      for (int i=0; i<count; i++)
         ss_sleep(10);
      return 1;
   }
 
   return 1;
}

read_event()

INT read_event	(	char *	pevent,
		INT	off
	)

Definition at line 403 of file feudp.cxx.

{
   char buf[MAX_UDP_SIZE];
   char bankname[5];
   
   int length = read_udp(gDataSocket, buf, MAX_UDP_SIZE, bankname);
   if (length <= 0)
      return 0;
   
   bk_init32(pevent);
   char* pdata;
   bk_create(pevent, bankname, TID_BYTE, (void**)&pdata);
   memcpy(pdata, buf, length);
   bk_close(pevent, pdata + length);
   return bk_size(pevent); 
}

Here is the call graph for this function:

read_udp()

int read_udp	(	int	socket,
		char *	buf,
		int	bufsize,
		char *	pbankname
	)

Definition at line 241 of file feudp.cxx.

{
   if (wait_udp(socket, 100) < 1)
      return 0;
 
#if 0
   static int count = 0;
   static double tt = 0;
   double t = GetTimeSec();
 
   double dt = (t-tt)*1e6;
   count++;
   if (dt > 1000) {
      printf("read_udp: %5d %6.0f usec\n", count, dt);
      count = 0;
   }
   tt = t;
#endif
 
   struct sockaddr addr;
   socklen_t addr_len = sizeof(addr);
   int rd = recvfrom(socket, buf, bufsize, 0, &addr, &addr_len);
   
   if (rd < 0) {
      cm_msg(MERROR, "read_udp", "recvfrom() returned %d, errno %d (%s)", rd, errno, strerror(errno));
      return -1;
   }
 
   for (unsigned i=0; i<gSrc.size(); i++) {
      if (addr_match(&gSrc[i], &addr, addr_len)) {
         mstrlcpy(pbankname, gSrc[i].bank_name, 5);
         //printf("rd %d, bank [%s]\n", rd, pbankname);
         return rd;
      }
   }
 
   if (gSkipUnknownPackets)
      return -1;
 
   Source sss;
 
   int status = find_source(&sss, &addr, addr_len);
 
   if (status < 0) {
 
      gUnknownPacketCount++;
 
      if (gUnknownPacketCount > 10) {
         gSkipUnknownPackets = true;
         cm_msg(MERROR, "read_udp", "further messages are now suppressed...");
         return -1;
      }
 
      return -1;
   }
 
   gSrc.push_back(sss);
         
   mstrlcpy(pbankname, sss.bank_name, 5);
         
   return rd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resume_run()

int resume_run	(	int	run,
		char *	err
	)

Resume Run.

Called every resume run transition.

Parameters

[in]	run_number	Number of the run being ended
[out]	error	Can be used to write a message string to midas.log

Returns

Midas status code

Definition at line 378 of file feudp.cxx.

{
   return SUCCESS;
}

wait_udp()

int wait_udp	(	int	socket,
		int	msec
	)

Definition at line 161 of file feudp.cxx.

{
   int status;
   fd_set fdset;
   struct timeval timeout;
 
   FD_ZERO(&fdset);
   FD_SET(socket, &fdset);
 
   timeout.tv_sec = msec/1000;
   timeout.tv_usec = (msec%1000)*1000;
 
   status = select(socket+1, &fdset, NULL, NULL, &timeout);
 
#ifdef EINTR
   if (status < 0 && errno == EINTR) {
      return 0; // watchdog interrupt, try again
   }
#endif
 
   if (status < 0) {
      cm_msg(MERROR, "wait_udp", "select() returned %d, errno %d (%s)", status, errno, strerror(errno));
      return -1;
   }
 
   if (status == 0) {
      return 0; // timeout
   }
 
   if (FD_ISSET(socket, &fdset)) {
      return 1; // have data
   }
 
   // timeout
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

display_period

int display_period = 0

Definition at line 26 of file feudp.cxx.

equipment

EQUIPMENT equipment[]

Initial value:

= {
   { EQ_NAME,                         
      {EQ_EVID, 0, "SYSTEM",          
       EQ_MULTITHREAD, 0, "MIDAS",    
       TRUE, RO_ALWAYS,               
       50, 0, 0, 0,                   
       "", "", "",}, read_event,      
   },
   {""}
}

Definition at line 52 of file feudp.cxx.

                        {
   { EQ_NAME,                         /* equipment name */
      {EQ_EVID, 0, "SYSTEM",          /* event ID, trigger mask, Evbuf */
       EQ_MULTITHREAD, 0, "MIDAS",    /* equipment type, EventSource, format */
       TRUE, RO_ALWAYS,               /* enabled?, WhenRead? */
       50, 0, 0, 0,                   /* poll[ms], Evt Lim, SubEvtLim, LogHist */
       "", "", "",}, read_event,      /* readout routine */
   },
   {""}
};

equipment_common_overwrite

BOOL equipment_common_overwrite = FALSE

Definition at line 50 of file feudp.cxx.

event_buffer_size

int event_buffer_size = 8*1024*1024

Definition at line 29 of file feudp.cxx.

frontend_call_loop

BOOL frontend_call_loop = TRUE

Definition at line 25 of file feudp.cxx.

frontend_file_name

const char* frontend_file_name = __FILE__

Definition at line 23 of file feudp.cxx.

frontend_name

const char* frontend_name = "feudp"

Definition at line 22 of file feudp.cxx.

gDataSocket

int gDataSocket

static

Definition at line 85 of file feudp.cxx.

gSkipUnknownPackets

bool gSkipUnknownPackets = false

static

Definition at line 88 of file feudp.cxx.

gSrc

std::vector<Source> gSrc

static

Definition at line 80 of file feudp.cxx.

gUnknownPacketCount

int gUnknownPacketCount = 0

static

Definition at line 87 of file feudp.cxx.

hKeySet

HNDLE hKeySet

static

Definition at line 83 of file feudp.cxx.

max_event_size

int max_event_size = 1*1024*1024

Definition at line 27 of file feudp.cxx.

max_event_size_frag

int max_event_size_frag = 5 * 1024 * 1024

Definition at line 28 of file feudp.cxx.