rototalk.c File Reference

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <errno.h>
#include "msgLog.h"
#include <string.h>
#include "rototalk.h"
#include "rotoMessages.h"

Go to the source code of this file.

Classes
struct	roto_conn
struct	roto_dcsfile
struct	roto_beammonfile
Defines
#define	MINBUFFERSIZE   2*1024*1024
#define	REPLYBUFFERSIZE   4096
#define	ctorRooterCmd(cmd)
Typedefs
typedef long int	rotocmd
Functions
rotocmd	roto_complete_cmd (rotocmd cmd, int whoami)
int	roto_send_command (rotocmd cmd, const void *buffer, int nsendbytes)
int	roto_set_std_file_status (rotocmd cmd, int entity, int det, int tag1, int tag2)
int	roto_set_named_file_status (rotocmd cmd, const char *fname)
int	roto_recv_cmdreply (rotocmd cmd)
int	roto_check_ack (rotocmd cmd, int ack)
int	roto_recv_reqreply (rotocmd cmd)
int	roto_reallocate_sendbuffer (int minsize)
int	roto_readn (int fd, char *ptr, int nbytes)
int	roto_writen (int fd, const char *ptr, int nbytes)
int	roto_open_DCP_connection (const char *host)
int	roto_open_DCS_connection (const char *host)
int	roto_open_BeamMon_connection (const char *host)
int	roto_open_connection (const char *host, int port, int whoami)
int	roto_set_connection_nodelay (int val)
int	roto_close_connection ()
int	roto_send_record (const void *buffer, int nbytes)
int	roto_send_autosave_config (const char *stream, unsigned int nrec, unsigned int nsec)
int	roto_send_compress_config (const char *stream, int level)
int	roto_send_basketsize_config (const char *stream, int bsize)
int	roto_open_daqfile (int detector, int run, int subrun)
int	roto_close_daqfile (int detector, int run, int subrun)
int	roto_open_dcsfile (int detector, int sec, int nsec)
int	roto_close_dcsfile ()
int	roto_open_beammonfile (int sec, int nsec)
int	roto_close_beammonfile ()
int	roto_open_named_file (const char *fname)
int	roto_close_named_file (const char *fname)
int	roto_request_shutdown (int priority)
Variables
int	roto_verbose = 0
int	iam = 0
roto_conn	g_roto_conn
roto_dcsfile	g_roto_dcsfile
roto_beammonfile	g_roto_beammonfile
int	last_ack
int	last_statereport
int	sendbuffer_size = 0
char *	sendbuffer = 0
long int *	cmdword
long int *	sizeword
char *	datastart
char	replybuffer [REPLYBUFFERSIZE]
const long int	roto_connect = ctorRooterCmd(MINOS_ROOTER_OPENSOCKET)
const long int	roto_disconn = ctorRooterCmd(MINOS_ROOTER_CLOSESOCKET)
const long int	roto_openf = ctorRooterCmd(MINOS_ROOTER_OPENFILE)
const long int	roto_closef = ctorRooterCmd(MINOS_ROOTER_CLOSEFILE)
const long int	roto_recbuff = ctorRooterCmd(MINOS_ROOTER_RECBUFFER)
const long int	roto_shutdown = ctorRooterCmd(MINOS_ROOTER_SHUTDOWN)
const long int	roto_config = ctorRooterCmd(MINOS_ROOTER_CONFIG)
const long int	roto_datatofollow = RC_DATAFLAG_MASK

---

Define Documentation

#define ctorRooterCmd (  cmd   )

Value: ( MINOS_ROOTER_ROOTER << RC_TO_BITPOS | \ MINOS_ROOTER_COMMAND << RC_TYPE_BITPOS | \ cmd ) Definition at line 115 of file rototalk.c.

#define MINBUFFERSIZE   2*1024*1024

Definition at line 98 of file rototalk.c.

#define REPLYBUFFERSIZE   4096

Definition at line 104 of file rototalk.c.

---

Typedef Documentation

typedef long int rotocmd

Definition at line 163 of file rototalk.c. Referenced by roto_close_connection(), roto_complete_cmd(), roto_open_connection(), roto_request_shutdown(), roto_send_autosave_config(), roto_send_basketsize_config(), roto_send_compress_config(), and roto_send_record().

---

Function Documentation

int roto_check_ack (  rotocmd  cmd, int  ack )

Definition at line 1261 of file rototalk.c. References MINOS_ROOTER_ACKNOWLEDGE, RC_FROM_BITPOS, RC_TO_BITPOS, RC_TYPE_BITPOS, and rototalk_success. Referenced by roto_recv_cmdreply(). { int oldfrom = (cmd & RC_FROM_MASK) >> RC_FROM_BITPOS; int oldto = (cmd & RC_TO_MASK) >> RC_TO_BITPOS; /* int oldtype = (cmd & RC_TYPE_MASK) >> RC_TYPE_BITPOS; */ int oldinstr = (cmd & RC_COMMAND_MASK) >> RC_COMMAND_BITPOS; /* * swap "to" and "from" * type should be ACK * same command */ int expect = oldfrom << RC_TO_BITPOS | oldto << RC_FROM_BITPOS | MINOS_ROOTER_ACKNOWLEDGE << RC_TYPE_BITPOS | oldinstr << RC_COMMAND_BITPOS; return (expect == ack) ? rototalk_success : rototalk_err_nack; }

int roto_close_beammonfile (   )

Definition at line 836 of file rototalk.c. References g_roto_beammonfile, MINOS_ROOTER_BEAMMON, roto_beammonfile::nsec, roto_closef, roto_set_std_file_status(), and roto_beammonfile::sec. Referenced by BeamData::close_file(), RotoClient::CloseBeamMonFile(), roto_open_beammonfile(), and send_bogus_stuff(). { int err; err = roto_set_std_file_status(roto_closef,MINOS_ROOTER_BEAMMON,0, g_roto_beammonfile.sec, g_roto_beammonfile.nsec); if (!err) { g_roto_beammonfile.sec = 0; g_roto_beammonfile.nsec = 0; } return err; }

int roto_close_connection (   )

Definition at line 401 of file rototalk.c. References roto_conn::conn_host, roto_conn::conn_nrec_sent, roto_conn::conn_port, roto_conn::conn_socketfd, g_roto_conn, iam, logError(), logInfo(), roto_complete_cmd(), roto_disconn, roto_recv_cmdreply(), roto_send_command(), roto_verbose, and rotocmd. Referenced by BeamData::close_connection(), RotoClient::CloseConnection(), and main(). { rotocmd cmd; int err; /* * complain if we aren't actually connected */ if (g_roto_conn.conn_socketfd<0) { logError("roto_close_connection: not connected"); return rototalk_err_notconnected; } /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(roto_disconn,iam); err = roto_send_command(cmd,0,0); if (err) return err; /* * Get the command reply (ACK|NACK + state report) */ err = roto_recv_cmdreply(cmd); /* vicious (cf. man -S 2 shutdown) without regard to further send/receives shutdown(conn_socket,2) */ /* * friendly closing of the socket */ errno = 0; while ( close(g_roto_conn.conn_socketfd) == -1 && errno == EINTR ) errno = 0; /* * make a note that we're not connected */ g_roto_conn.conn_socketfd = -1; strcpy(g_roto_conn.conn_host,"no-longer-connected"); g_roto_conn.conn_port = 0; g_roto_conn.conn_nrec_sent = 0; if (roto_verbose>0) logInfo("roto_close_connection requested"); return err; }

int roto_close_daqfile (  int  detector, int  run, int  subrun )

Definition at line 674 of file rototalk.c. References MINOS_ROOTER_DCP, roto_closef, roto_set_std_file_status(), and run(). Referenced by RotoClient::CloseDAQFile(). { return roto_set_std_file_status(roto_closef,MINOS_ROOTER_DCP, detector,run,subrun); }

int roto_close_dcsfile (   )

Definition at line 751 of file rototalk.c. References roto_dcsfile::detector, g_roto_dcsfile, MINOS_ROOTER_DCS, roto_dcsfile::nsec, roto_closef, roto_set_std_file_status(), and roto_dcsfile::sec. Referenced by RotoClient::CloseDCSFile(), and roto_open_dcsfile(). { int err; err = roto_set_std_file_status(roto_closef,MINOS_ROOTER_DCS, g_roto_dcsfile.detector, g_roto_dcsfile.sec, g_roto_dcsfile.nsec); if (!err) { g_roto_dcsfile.detector = 0; g_roto_dcsfile.sec = 0; g_roto_dcsfile.nsec = 0; } return err; }

int roto_close_named_file (  const char *  fname  )

Definition at line 883 of file rototalk.c. References roto_closef, and roto_set_named_file_status(). Referenced by RotoClient::CloseFile(), and send_whole_file(). { return roto_set_named_file_status(roto_closef,fname); }

rotocmd roto_complete_cmd (  rotocmd  cmd, int  whoami )

Definition at line 1082 of file rototalk.c. References rotocmd. Referenced by roto_close_connection(), roto_open_connection(), roto_request_shutdown(), roto_send_autosave_config(), roto_send_basketsize_config(), roto_send_compress_config(), roto_send_record(), roto_set_named_file_status(), and roto_set_std_file_status(). { return ((whoami<< RC_FROM_BITPOS) | cmd); }

int roto_open_BeamMon_connection (  const char *  host  )

Definition at line 203 of file rototalk.c. References MINOS_ROOTER_BEAMMON, ROOTER_PORT_BEAMMON, and roto_open_connection(). Referenced by main(), and BeamData::open_connection(). { return roto_open_connection(host,ROOTER_PORT_BEAMMON,MINOS_ROOTER_BEAMMON); }

int roto_open_beammonfile (  int  sec, int  nsec )

Definition at line 785 of file rototalk.c. References g_roto_beammonfile, logError(), MINOS_ROOTER_BEAMMON, roto_beammonfile::nsec, roto_close_beammonfile(), roto_openf, roto_set_std_file_status(), and roto_beammonfile::sec. Referenced by BeamData::open_file(), RotoClient::OpenBeamMonFile(), and send_bogus_stuff(). { int err; if (g_roto_beammonfile.sec != 0 || g_roto_beammonfile.nsec != 0 ) { /* a file is already open */ if (g_roto_beammonfile.sec == sec || g_roto_beammonfile.nsec == nsec ) { /* do nothing, requested the same file ... */ return rototalk_success; } /* a different file is already open! */ logError("roto_open_beammonfile:"); logError(" a file (0x%8.8x 0x%8.8x) is already open", g_roto_beammonfile.sec,g_roto_beammonfile.nsec); logError(" close it and open (0x%8.8x 0x%8.8x)", sec,nsec); roto_close_beammonfile(); } err = roto_set_std_file_status(roto_openf,MINOS_ROOTER_BEAMMON, 0,sec,nsec); if (!err) { g_roto_beammonfile.sec = sec; g_roto_beammonfile.nsec = nsec; } return err; }

int roto_open_connection (  const char *  host, int  port, int  whoami )

Definition at line 224 of file rototalk.c. References roto_conn::conn_host, roto_conn::conn_nrec_sent, roto_conn::conn_port, roto_conn::conn_socketfd, g_roto_conn, iam, logDebug(), logError(), logInfo(), logWarn(), MINOS_ROOTER_BEAMMON, MINOS_ROOTER_DCP, MINOS_ROOTER_DCS, port, roto_complete_cmd(), roto_connect, roto_recv_cmdreply(), roto_send_command(), roto_set_connection_nodelay(), roto_verbose, and rotocmd. Referenced by main(), roto_open_BeamMon_connection(), roto_open_DCP_connection(), roto_open_DCS_connection(), and RotoClient::SetupConnection(). { const char *whoami_name = "unknown"; int socketfd = 0; struct hostent *host_ptr; struct sockaddr_in serv_addr; unsigned long int addr; /* good for 4 byte address */ struct in_addr ad; int err; rotocmd cmd; switch (whoami) { case MINOS_ROOTER_DCP: whoami_name = "DCP"; break; case MINOS_ROOTER_DCS: whoami_name = "DCS"; break; case MINOS_ROOTER_BEAMMON: whoami_name = "BeamMon"; break; default: logError("roto_open_connection: whoami 0x%02x is not allowed",whoami); return rototalk_err_whoami; } iam = whoami; if (g_roto_conn.conn_socketfd>0) { logError("roto_open_connection: already established to %s:%d", g_roto_conn.conn_host,g_roto_conn.conn_port); /* * should we close that connection and reopen * or simply return a failure?? * ... for now simply leave existing one open */ return rototalk_err_alreadyconn; } /* * code based on both: * Unix Network Programming, W. Richard Stevens, Prentice Hall, pg 286 * ROOT TSocket and TUnixSystem classes */ /* * prepare the address structure */ memset(&serv_addr,0,sizeof(serv_addr)); /* clear the structure */ #ifdef HASNOT_INETATON logWarn("roto_open_connection: using obsolete inet_addr() function"); if ((addr = (unsigned long int)inet_addr(host)) != INADDR_NONE) { #else if (inet_aton(host, &ad)) { memcpy(&addr, &ad.s_addr, sizeof(ad.s_addr)); #endif if (!(host_ptr = gethostbyaddr((const char *)&addr, sizeof(addr), AF_INET))) { /* unnamed host */ } } else if ((host_ptr = gethostbyname(host))) { logDebug(3,"roto_open_connection: resorted to gethostbyname"); } if (!host_ptr) { logError("roto_open_connection: unknown host %s",host); return rototalk_err_unknownhost; } if (host_ptr->h_addrtype != AF_INET) { logError("roto_open_connection: %s not an internet host",host); return rototalk_err_notinethost; } /* * Magic incantation */ memcpy(&addr,host_ptr->h_addr,host_ptr->h_length); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = addr; serv_addr.sin_port = htons(port); /* * Open the TCP socket (an Internet stream socket) */ if ( (socketfd = socket(AF_INET,SOCK_STREAM, 0)) < 0 ) { logError("roto_open_connection: failed to open socket"); return rototalk_err_socketfail; } /* * Connect to the server */ if (connect(socketfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) { logError("roto_open_connection: can't connect"); logError(" host '%s' expanded '%s' port %d",host,host_ptr->h_name,port); logError(" sin_addr.s_addr 0x%8.8x sin_port 0x%4.4x", serv_addr.sin_addr.s_addr,serv_addr.sin_port); return rototalk_err_connectfail; } /* * Save a copy of who we're connected to */ g_roto_conn.conn_socketfd = socketfd; strcpy(g_roto_conn.conn_host,host_ptr->h_name); /* copy the expanded name */ g_roto_conn.conn_port = port; g_roto_conn.conn_nrec_sent = 0; /* * by default make connection use TCP_NODELAY */ roto_set_connection_nodelay(1); if (roto_verbose>0) { logInfo("roto_open_connection: %s:%d, i am '%s'", host,port,whoami_name); } /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(roto_connect,iam); err = roto_send_command(cmd,0,0); if (err) return err; /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_open_daqfile (  int  detector, int  run, int  subrun )

Definition at line 653 of file rototalk.c. References MINOS_ROOTER_DCP, roto_openf, roto_set_std_file_status(), and run(). Referenced by RotoClient::OpenDAQFile(). { return roto_set_std_file_status(roto_openf,MINOS_ROOTER_DCP, detector,run,subrun); }

int roto_open_DCP_connection (  const char *  host  )

Definition at line 195 of file rototalk.c. References MINOS_ROOTER_DCP, ROOTER_PORT_DAQ, and roto_open_connection(). Referenced by main(). { return roto_open_connection(host,ROOTER_PORT_DAQ,MINOS_ROOTER_DCP); }

int roto_open_DCS_connection (  const char *  host  )

Definition at line 199 of file rototalk.c. References MINOS_ROOTER_DCS, ROOTER_PORT_DCS, and roto_open_connection(). Referenced by main(). { return roto_open_connection(host,ROOTER_PORT_DCS,MINOS_ROOTER_DCS); }

int roto_open_dcsfile (  int  detector, int  sec, int  nsec )

Definition at line 698 of file rototalk.c. References roto_dcsfile::detector, g_roto_dcsfile, logError(), MINOS_ROOTER_DCS, roto_dcsfile::nsec, roto_close_dcsfile(), roto_openf, roto_set_std_file_status(), and roto_dcsfile::sec. Referenced by RotoClient::OpenDCSFile(). { int err; if (g_roto_dcsfile.detector != 0 || g_roto_dcsfile.sec != 0 || g_roto_dcsfile.nsec != 0 ) { /* a file is already open */ if (g_roto_dcsfile.detector == detector || g_roto_dcsfile.sec == sec || g_roto_dcsfile.nsec == nsec ) { /* do nothing, requested the same file ... */ return rototalk_success; } /* a different file is already open! */ logError("roto_open_dcsfile:"); logError(" a file (0x%2.2x 0x%8.8x 0x%8.8x) is already open", g_roto_dcsfile.detector,g_roto_dcsfile.sec,g_roto_dcsfile.nsec); logError(" close it and open (0x%2.2x 0x%8.8x 0x%8.8x)", detector,sec,nsec); roto_close_dcsfile(); } err = roto_set_std_file_status(roto_openf,MINOS_ROOTER_DCS, detector,sec,nsec); if (!err) { g_roto_dcsfile.detector = detector; g_roto_dcsfile.sec = sec; g_roto_dcsfile.nsec = nsec; } return err; }

int roto_open_named_file (  const char *  fname  )

Definition at line 864 of file rototalk.c. References roto_openf, and roto_set_named_file_status(). Referenced by RotoClient::OpenFile(), and send_whole_file(). { return roto_set_named_file_status(roto_openf,fname); }

int roto_readn (  int  fd, char *  ptr, int  nbytes )

Definition at line 1377 of file rototalk.c. Referenced by roto_recv_cmdreply(). { int nleft, nread; nleft = nbytes; while (nleft > 0) { nread = read(fd, ptr, nleft); if (nread < 0) return nread; /* error, return < 0 */ else if (nread == 0) break; /* EOF */ nleft -= nread; ptr += nread; } return (nbytes-nleft); /* return >= 0 */ }

int roto_reallocate_sendbuffer (  int  minsize  )

Definition at line 1319 of file rototalk.c. References cmdword, datastart, logError(), logInfo(), sendbuffer, sendbuffer_size, and sizeword. Referenced by roto_send_command(). { int oldsize = sendbuffer_size; int mrequest = minsize; int failures = 0; if (sendbuffer) { free(sendbuffer); /* release existing buffer */ sendbuffer = 0; } /* set absolute mimimum */ if (mrequest<MINBUFFERSIZE) mrequest = MINBUFFERSIZE; while ( ! sendbuffer ) { sendbuffer = (char*)malloc(mrequest); if (sendbuffer) break; /* success !!! */ failures++; mrequest -= 1024*sizeof(char); /* failed, try smaller size */ } sendbuffer_size = mrequest; /* set pointers to short cuts */ cmdword = (long int*)sendbuffer; sizeword = cmdword + 1; datastart = sendbuffer + 2*sizeof(long int); if (sendbuffer_size<minsize) { logError("roto_reallocate_sendbuffer: from %d to %d failed, only have %d", oldsize,minsize,sendbuffer_size); return rototalk_err_reallocate; } else { logInfo("roto_reallocate_sendbuffer: from %d to %d", oldsize,sendbuffer_size); return rototalk_success; } }

int roto_recv_cmdreply (  rotocmd  cmd  )

Definition at line 1165 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, last_ack, last_statereport, logError(), replybuffer, roto_check_ack(), and roto_readn(). Referenced by roto_close_connection(), roto_open_connection(), roto_request_shutdown(), roto_send_autosave_config(), roto_send_basketsize_config(), roto_send_compress_config(), roto_send_record(), roto_set_named_file_status(), and roto_set_std_file_status(). { int nread; int nreply; if (g_roto_conn.conn_socketfd<0) { logError("roto_recv_cmdreply: not connected"); return rototalk_err_notconnected; } /* * Read the ACK/NACK */ nread = roto_readn(g_roto_conn.conn_socketfd,(char*)&last_ack,sizeof(int)); if (nread != sizeof(int)) return rototalk_err_badrecvack; if (last_ack & roto_datatofollow) { /* there was some reply data ... how odd */ nread = roto_readn(g_roto_conn.conn_socketfd, (char*)&nreply,sizeof(int)); if (nread != sizeof(int)) return rototalk_err_badrecvacksize; nreply -= sizeof(int); /* byte count is inclusive */ nread = roto_readn(g_roto_conn.conn_socketfd, (char*)replybuffer,nreply); if (nreply != nread) return rototalk_err_badrecvackdata; } /* * Read the state report */ nread = roto_readn(g_roto_conn.conn_socketfd, (char*)&last_statereport,sizeof(int)); if (nread != sizeof(int)) return rototalk_err_badrecvstate; /* * Verify that we got a proper ACK */ return roto_check_ack(cmd,last_ack); }

int roto_recv_reqreply (  rotocmd  cmd  )

int roto_request_shutdown (  int  priority  )

Definition at line 1219 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, iam, logError(), logNotice(), roto_complete_cmd(), roto_recv_cmdreply(), roto_send_command(), roto_shutdown, roto_verbose, and rotocmd. Referenced by main(), and RotoClient::SendShutdownMessage(). { rotocmd cmd; int err; if (g_roto_conn.conn_socketfd<0) { logError("roto_request_shutdown: not connected"); return rototalk_err_notconnected; } /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(roto_shutdown,iam); err = roto_send_command(cmd,&priority,sizeof(int)); if (err) return err; if (roto_verbose>0) logNotice("roto_request_shutdown (priority=%d)",priority); /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_send_autosave_config (  const char *  stream, unsigned int  nrec, unsigned int  nsec )

Definition at line 510 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, iam, logDebug(), logError(), roto_complete_cmd(), roto_config, roto_recv_cmdreply(), roto_send_command(), roto_verbose, and rotocmd. { rotocmd cmd; int err; char minibuffer[4096]; if (g_roto_conn.conn_socketfd<0) { logError("roto_send_autosave_config: not connected"); return rototalk_err_notconnected; } if (roto_verbose>1) logDebug(2,"roto_send_autosave_config: stream \"%s\" - %d rec, %d sec", stream,nrec,nsec); /* format the config */ sprintf(minibuffer,"config autosave: %s = %d rec %d sec",stream,nrec,nsec); /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(roto_config,iam); err = roto_send_command(cmd,minibuffer,strlen(minibuffer)); if (err) return err; /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_send_basketsize_config (  const char *  stream, int  bsize )

Definition at line 604 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, iam, logDebug(), logError(), roto_complete_cmd(), roto_config, roto_recv_cmdreply(), roto_send_command(), roto_verbose, and rotocmd. { rotocmd cmd; int err; char minibuffer[4096]; if (g_roto_conn.conn_socketfd<0) { logError("roto_send_basketsize_config: not connected"); return rototalk_err_notconnected; } if (roto_verbose>1) logDebug(2,"roto_send_basketsize_config: stream \"%s\" - basketsize %d", stream,bsize); /* format the config */ sprintf(minibuffer,"config basketsize: %s = %d ",stream,bsize); /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(roto_config,iam); err = roto_send_command(cmd,minibuffer,strlen(minibuffer)); if (err) return err; /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_send_command (  rotocmd  cmd, const void *  buffer, int  nsendbytes )

Definition at line 1103 of file rototalk.c. References cmdword, roto_conn::conn_socketfd, datastart, g_roto_conn, logError(), roto_reallocate_sendbuffer(), roto_writen(), sendbuffer, sendbuffer_size, and sizeword. Referenced by roto_close_connection(), roto_open_connection(), roto_request_shutdown(), roto_send_autosave_config(), roto_send_basketsize_config(), roto_send_compress_config(), roto_send_record(), roto_set_named_file_status(), and roto_set_std_file_status(). { int has_data = ( nsendbytes>0 && buffer ); int databytes = nsendbytes + sizeof(long int); /* includes byte count */ int totmsgsize = databytes + sizeof(long int); /* includes command */ int nsent = 0; int realloc_status; if (g_roto_conn.conn_socketfd<0) { logError("roto_send_command: not connected"); return rototalk_err_notconnected; } if ( has_data ) cmd |= roto_datatofollow; errno = 0; /* * Compose send buffer with command and bytes-to-follow prepended * to the actual data, first making sure that the buffer is large enough */ if (sendbuffer_size < totmsgsize) { realloc_status = roto_reallocate_sendbuffer(totmsgsize); /* don't try to use more than we could allocate */ if (sendbuffer_size<totmsgsize) totmsgsize = sendbuffer_size; } *cmdword = cmd; if ( has_data) { *sizeword = databytes; memcpy(datastart,buffer,nsendbytes); } else totmsgsize = sizeof(long int); /* no data -> message is only command */ /* * Send the whole works in one shot (command + byte count + data) */ nsent = roto_writen(g_roto_conn.conn_socketfd, sendbuffer,totmsgsize); if (nsent != totmsgsize) return rototalk_err_badsendcmd; return rototalk_success; }

int roto_send_compress_config (  const char *  stream, int  level )

Definition at line 559 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, iam, logDebug(), logError(), roto_complete_cmd(), roto_config, roto_recv_cmdreply(), roto_send_command(), roto_verbose, and rotocmd. { rotocmd cmd; int err; char minibuffer[4096]; if (g_roto_conn.conn_socketfd<0) { logError("roto_send_compress_config: not connected"); return rototalk_err_notconnected; } if (roto_verbose>1) logDebug(2,"roto_send_compress_config: stream \"%s\" - compress %d", stream,level); /* format the config */ sprintf(minibuffer,"config compress: %s = %d ",stream,level); /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(roto_config,iam); err = roto_send_command(cmd,minibuffer,strlen(minibuffer)); if (err) return err; /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_send_record (  const void *  buffer, int  nbytes )

Definition at line 465 of file rototalk.c. References roto_conn::conn_nrec_sent, roto_conn::conn_socketfd, g_roto_conn, iam, logDebug(), logError(), roto_complete_cmd(), roto_recbuff, roto_recv_cmdreply(), roto_send_command(), roto_verbose, and rotocmd. Referenced by send_bogus_stuff(), BeamData::send_data(), send_whole_file(), and RotoClient::SendRecordBuffer(). { rotocmd cmd; int err; if (g_roto_conn.conn_socketfd<0) { logError("roto_send_record: not connected"); return rototalk_err_notconnected; } g_roto_conn.conn_nrec_sent++; if (roto_verbose>2) logDebug(3,"roto_send_record: record %d, %d bytes", g_roto_conn.conn_nrec_sent,nbytes); /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(roto_recbuff,iam); err = roto_send_command(cmd,buffer,nbytes); if (err) return err; /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_set_connection_nodelay (  int  val  )

Definition at line 366 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, logError(), logWarn(), and roto_verbose. Referenced by main(), and roto_open_connection(). { int err; /* * complain if we aren't actually connected */ if (g_roto_conn.conn_socketfd<0) { logError("roto_set_connection_nodelay: not connected"); return rototalk_err_notconnected; } err = setsockopt(g_roto_conn.conn_socketfd,IPPROTO_TCP,TCP_NODELAY, (char*)&val, sizeof(val)); if (roto_verbose>0 && err) logWarn("roto_set_connection_nodelay returned %d",err); return err; }

int roto_set_named_file_status (  rotocmd  cmd, const char *  fname )

Definition at line 1002 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, iam, logError(), logInfo(), logNotice(), MINOS_DCS, roto_complete_cmd(), roto_recv_cmdreply(), roto_send_command(), and roto_verbose. Referenced by roto_close_named_file(), and roto_open_named_file(). { const char* which_mode = "uknown request"; char minibuffer[1024]; int* iptr = (int*) minibuffer; char* cptr = minibuffer+sizeof(int); int fnlen, nbytes, err; /* * Make sure that the command is "open" or "close" */ if (cmd == roto_openf) { which_mode = "open"; } else if (cmd == roto_closef) { which_mode = "close"; } else { logError("roto_set_named_file_status: unknown mode 0x%8.8lx",cmd); return rototalk_err_illegalmethod; } if (g_roto_conn.conn_socketfd<0) { logError("roto_%s_named_file: not connected",which_mode); return rototalk_err_notconnected; } /* * server expects a mini-buffer with one of: * DCP: detector run subrun * DCS,BEAMMON: detector sec nsec * but we'll pass * (MINOS_DCS|roto_datatofollow) "filename" */ /* signal that we're giving a file name, not normal 4 int buffer */ *iptr = MINOS_DCS | roto_datatofollow; /* copy the filename into the buffer */ fnlen = strlen(fname); strcpy(cptr,fname); cptr[fnlen] = 0; /* whack in trailing \0 */ nbytes = sizeof(int) + fnlen + 1; if (roto_verbose>1) logNotice("roto_%s_named_file '%s' (%d bytes)", which_mode,cptr,nbytes); /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(cmd,iam); err = roto_send_command(cmd,minibuffer,nbytes); if (err) return err; if (roto_verbose>1) logInfo("roto_%s_named_file '%s' requested",which_mode,fname); /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_set_std_file_status (  rotocmd  cmd, int  entity, int  det, int  tag1, int  tag2 )

Definition at line 910 of file rototalk.c. References roto_conn::conn_socketfd, g_roto_conn, iam, logError(), logInfo(), MINOS_ROOTER_BEAMMON, MINOS_ROOTER_DCP, MINOS_ROOTER_DCS, roto_complete_cmd(), roto_recv_cmdreply(), roto_send_command(), and roto_verbose. Referenced by roto_close_beammonfile(), roto_close_daqfile(), roto_close_dcsfile(), roto_open_beammonfile(), roto_open_daqfile(), and roto_open_dcsfile(). { int err; const char* which_mode = "uknown request"; const char* which_entity = "unknown-type"; int minibuffer[4]; /* * Make sure that the command is "open" or "close" */ if (cmd == roto_openf) { which_mode = "open"; } else if (cmd == roto_closef) { which_mode = "close"; } else { logError("roto_set_std_file_status: unknown mode 0x%8.8lx",cmd); return rototalk_err_illegalmethod; } /* * Make sure it is tagged as either DCP (ie. DAQ) or DCS */ switch (entity) { case MINOS_ROOTER_DCP: which_entity = "daq"; break; case MINOS_ROOTER_DCS: which_entity = "dcs"; break; case MINOS_ROOTER_BEAMMON: which_entity = "beammon"; break; default: logError("roto_set_std_file_status: unknown entity 0x%8.8x",entity); return rototalk_err_badsender; break; } if (g_roto_conn.conn_socketfd<0) { logError("roto_%s_%sfile: not connected",which_mode,which_entity); return rototalk_err_notconnected; } /* * server expects a mini-buffer with one of: * DCP: detector run subrun * DCS,BEAMMON: detector sec nsec */ minibuffer[0] = entity; minibuffer[1] = detector; minibuffer[2] = tag1; minibuffer[3] = tag2; /* * Send "command" in fashion similar to run control protocol */ cmd = roto_complete_cmd(cmd,iam); err = roto_send_command(cmd,(char*)minibuffer,4*sizeof(int)); if (err) return err; if (roto_verbose>1) logInfo("roto_%s_%sfile det %d tag1 %d tag2 %d\n", which_mode,which_entity,detector,tag1,tag2); /* * Get the command reply (ACK|NACK + state report) */ return roto_recv_cmdreply(cmd); }

int roto_writen (  int  fd, const char *  ptr, int  nbytes )

Definition at line 1411 of file rototalk.c. Referenced by roto_send_command(). { int nleft, nwritten; nleft = nbytes; while (nleft > 0) { nwritten = write(fd, ptr, nleft); if (nwritten<=0) return nwritten; /* error */ nleft -= nwritten; ptr += nwritten; } return (nbytes-nleft); }

---

Variable Documentation

long int* cmdword

Definition at line 95 of file rototalk.c. Referenced by roto_reallocate_sendbuffer(), and roto_send_command().

char* datastart

Definition at line 97 of file rototalk.c. Referenced by roto_reallocate_sendbuffer(), and roto_send_command().

struct roto_beammonfile g_roto_beammonfile

Referenced by roto_close_beammonfile(), and roto_open_beammonfile().

struct roto_conn g_roto_conn

Referenced by roto_close_connection(), roto_open_connection(), roto_recv_cmdreply(), roto_request_shutdown(), roto_send_autosave_config(), roto_send_basketsize_config(), roto_send_command(), roto_send_compress_config(), roto_send_record(), roto_set_connection_nodelay(), roto_set_named_file_status(), and roto_set_std_file_status().

struct roto_dcsfile g_roto_dcsfile

Referenced by roto_close_dcsfile(), and roto_open_dcsfile().

int iam = 0

Definition at line 47 of file rototalk.c. Referenced by roto_close_connection(), roto_open_connection(), roto_request_shutdown(), roto_send_autosave_config(), roto_send_basketsize_config(), roto_send_compress_config(), roto_send_record(), roto_set_named_file_status(), and roto_set_std_file_status().

int last_ack

Initial value: MINOS_ROOTER_ROOTER << RC_FROM_BITPOS | \ MINOS_ROOTER_UNABLE_TO << RC_TYPE_BITPOS | \ END_OF_MINOS_ROOTER_COMMAND_TYPES Definition at line 80 of file rototalk.c. Referenced by roto_recv_cmdreply().

int last_statereport

Initial value: MINOS_ROOTER_ROOTER << RC_FROM_BITPOS | \ MINOS_ROOTER_STATE_REPORT << RC_TYPE_BITPOS | \ END_OF_MINOS_ROOTER_STATES Definition at line 84 of file rototalk.c. Referenced by roto_recv_cmdreply().

char replybuffer[REPLYBUFFERSIZE]

Definition at line 105 of file rototalk.c. Referenced by roto_recv_cmdreply().

const long int roto_closef = ctorRooterCmd(MINOS_ROOTER_CLOSEFILE)

Definition at line 122 of file rototalk.c. Referenced by roto_close_beammonfile(), roto_close_daqfile(), roto_close_dcsfile(), and roto_close_named_file().

const long int roto_config = ctorRooterCmd(MINOS_ROOTER_CONFIG)

Definition at line 125 of file rototalk.c. Referenced by roto_send_autosave_config(), roto_send_basketsize_config(), and roto_send_compress_config().

const long int roto_connect = ctorRooterCmd(MINOS_ROOTER_OPENSOCKET)

Definition at line 119 of file rototalk.c. Referenced by roto_open_connection().

const long int roto_datatofollow = RC_DATAFLAG_MASK

Definition at line 156 of file rototalk.c.

const long int roto_disconn = ctorRooterCmd(MINOS_ROOTER_CLOSESOCKET)

Definition at line 120 of file rototalk.c. Referenced by roto_close_connection().

const long int roto_openf = ctorRooterCmd(MINOS_ROOTER_OPENFILE)

Definition at line 121 of file rototalk.c. Referenced by roto_open_beammonfile(), roto_open_daqfile(), roto_open_dcsfile(), and roto_open_named_file().

const long int roto_recbuff = ctorRooterCmd(MINOS_ROOTER_RECBUFFER)

Definition at line 123 of file rototalk.c. Referenced by roto_send_record().

const long int roto_shutdown = ctorRooterCmd(MINOS_ROOTER_SHUTDOWN)

Definition at line 124 of file rototalk.c. Referenced by roto_request_shutdown().

int roto_verbose = 0

Definition at line 44 of file rototalk.c. Referenced by main(), roto_close_connection(), roto_open_connection(), roto_request_shutdown(), roto_send_autosave_config(), roto_send_basketsize_config(), roto_send_compress_config(), roto_send_record(), roto_set_connection_nodelay(), roto_set_named_file_status(), and roto_set_std_file_status().

char* sendbuffer = 0

Definition at line 94 of file rototalk.c. Referenced by roto_reallocate_sendbuffer(), and roto_send_command().

int sendbuffer_size = 0

Definition at line 93 of file rototalk.c. Referenced by roto_reallocate_sendbuffer(), and roto_send_command().

long int* sizeword

Definition at line 96 of file rototalk.c. Referenced by roto_reallocate_sendbuffer(), and roto_send_command().

---