ngcbSIO.hpp

Go to the documentation of this file.

#ifndef ngcbSIO_H
#define ngcbSIO_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
 
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbSocket.h>
#include <poll.h>

#define ngcbSIO_MAX_CON 16

#define ngcbSIO_MAX_PORT 4

#define ngcbSIO_MAX_FD 64
 
#define ngcbSIO_NFDS (ngcbSIO_MAX_FD + (ngcbSIO_MAX_CON * 2) + ngcbSIO_MAX_PORT + 4)
 
/*
 * Tokens for system control
 */
#define ngcbSIO_CMD_EXIT       0x00000010  //< EXIT command
#define ngcbSIO_CMD_RESET      0x00000020  //< RESET command
#define ngcbSIO_CMD_PING       0x00000040  //< PING command
#define ngcbSIO_CMD_CONNECT    0x00000080  //< CONNECT command
#define ngcbSIO_CMD_DISCONNECT 0x00000100  //< DISCONNECT command
#define ngcbSIO_CMD_TIMEOUT    0x00000200  //< TIMEOUT command
#define ngcbSIO_CMD_SIMULAT    0x00000400  //< SIMULATION command
#define ngcbSIO_CMD_STOPSIM    0x00000800  //< STOP SIMULATION command
#define ngcbSIO_CMD_STATUS     0x00001000  //< STATUS command
 
 
/*
 * Supported protocols
 */
#define ngcbSIO_PROTOCOL_GENERIC 0  //< Generic protocol
#define ngcbSIO_PROTOCOL_BIN     1  //< Binary protocol
#define ngcbSIO_PROTOCOL_ASCII   2  //< ASCII protocol
#define ngcbSIO_PROTOCOL_ASCII0  3  //< raw ASCII (no startup messages) 

struct ngcb_port_t {
  int socket;
            
  int protocol;  

  int port;  

  ngcb_port_t() {
    socket = -1;  // not open
    protocol = 0; // use standard protocol
    port = 0;
  }
};

class ngcbSIO
{ 
public:
  ngcbSIO();                   

  virtual ~ngcbSIO();

  int verboseLevel;

  int logLevel;   

  int ignoreSignal;        

  char *ErrMsg() {return (erms_);}
  
 
  /*
   * Common socket i/o
   */

  int PortNum(int fd);

  int GetIpAddr(const char *name, char *ipAddr);

  int WaitSocket(int fd, int timeout);

  int TcpService(const char *service = NULL);

  int TcpService(int port);

  int TcpAccept(int srvSocket);

  int TcpConnect(const char *service);

  int TcpConnect(int port, const char *host = NULL);

  int TcpClose(int fd);

  int TcpRead(int fd, void *buffer, size_t size);

  int TcpWrite(int fd, const void *buffer, size_t size);

  int TcpPuts(int fd, const char *string);

  int TcpGets(int fd, char *string, int maxLen);

  int TcpReadRequest(int fd, char *request, int maxSize);

  int TcpWriteReply(int fd, const char *reply, int success);

  int ExecVersion(const char *host);

  int Exec(const char *host, const char *cmd, char *reply, int port = 0);

  int ExecXt(const char *host, const char *cmd, char *reply, 
         const char *geom = NULL);

  int Kill(const char *host, int pid);

  void ExecReply(int fd, char success, const char *reply);
 
 
  /*
   * Command/event client interface
   */

  int Discover(const char *host, const char *name, const char *instance,
           int *port, int *protocol = NULL);
  
  int Discover(const char *name, const char *instance, int *port, 
           int *protocol = NULL);
  
  int Connect(const char *host, int port, int protocol, int *evtPort);
  
  int Connect(const char *host, int port, int protocol);

  int Connect(const char *service, int protocol = ngcbSIO_PROTOCOL_ASCII);

  void Disconnect();

  int Connected();

  void ReplyBufferSize(size_t size);

  int SendRequest(const char *request);

  int GetReply(char *s = NULL);

  int PrintReply(FILE *fd);

  int ReplyLine(char *line);

  char *Reply() {return (replyBuffer_);}

  int RequestReply(const char *request, char *reply = NULL);
 
  /*
   * Server interface
   */
  
  int OpenServer(int cmdPort, int evtPort = -1);

  void CloseServer();

  void StopServer();

  int SrvOpened();

  virtual void SetSrvAborted(int flag);

  virtual int SrvAborted();

  int SrvCmdPort();

  int SrvEvtPort();

  int SrvCmdSocket();
  
  int SrvEvtSocket();

  int OpenPort(int port, int protocol = 0);

  int ClosePort(int port);

  int Port2Fd(int port);

  int Fd2Port(int fd);

  int ConnectCmd(int srvSocket, int protocol = 0);

  int NumCmdClient();

  int HaveCmdClient();
  
  int ConnectEvt(int srvSocket);

  int NumEvtClient();

  int HaveEvtClient();
  
  void Broadcast(const void *buffer, size_t size);

  void Broadcast(const char *s);

  int Protocol(int fd);

  int ProtocolType();

  void ProtocolType(int protocol);

  int GetProtocol(int fd);

  void EnableStdIn();

  void DisableStdIn();

  int StdIn();

  int FdAttach(int fd);

  void FdDetach(int fd);

  void TimerSet(int ms);

  void TimerOn();

  void TimerOff();

  int MainLoop();

  void Lock();

  void Unlock();

  void CleanupCmd(char *cmdLine, int *cmdLen);

  virtual void Verbose(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  virtual void Verbose(int level, const char *format, ...)
    __attribute__ ((format(printf, 3, 4)));

  virtual void Log(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  virtual void Log(int level, const char *format, ...)
    __attribute__ ((format(printf, 3, 4)));

  virtual void LogMsg(const char *msg);
 
protected:
  virtual int ProtocolBin(int fd);

  virtual int ProtocolAscii(int fd);

  virtual int Service(int fd, int protocol);

  virtual int ServiceConnect(int fd, int protocol);

  virtual void ProtocolErr(const char *erms);

  virtual int RegisterService(int fd);

  virtual int UnregisterService(int fd);

  virtual int NewEventConnection(int fd);

  virtual int FdCB(int fd);

  virtual int TimerCB();

  virtual void MainLoopInit();
  
private:
  char erms_[256];

  char versionString_[256];

  int endian_;
  
  int clientStat_;

  FILE *fdIn_;

  FILE *fdOut_;

  int fdLock_[2];

  char *replyBuffer_;
  
  size_t replyBufferSize_;
  
  int srvCmdPort_;
  
  int srvEvtPort_;

  ngcb_port_t port_[ngcbSIO_MAX_PORT];

  int protocol_;

  int protocolStd_;

  int srvOpen_;

  int srvAbort_;

  int execReplyDone_;
  
  int srvCmdSocket_;

  int srvEvtSocket_;

  int stdin_;

  struct pollfd fds_[ngcbSIO_NFDS];

  int nfds_;

  int fd_[ngcbSIO_MAX_FD];

  int cmdSocket_[ngcbSIO_MAX_CON];
  
  int evtSocket_[ngcbSIO_MAX_CON];

  int cmdProtocol_[ngcbSIO_MAX_CON];

  struct timeval timerVal_;
  
  struct timeval ts_;

  int timerEnabled_;

  int CmdSocketIdx_(int fd);

  int EvtSocketIdx_(int fd);

  int FdIsSet_(int fd);

  void FdSet_(int fd);

  void FdClr_(int fd);
  
  int FdValid_(int fd);

  void Host_(const char *host, char *name, int n = 64);
};
 
#endif