HLTSocket Class Reference

Public Member Functions
int	put (char *data, int len)
int	put_wordbuf (int *data, int len)
int	get (char *data, int len)
int	get_wordbuf (int *data, int len)
bool	accept (unsigned int port)
bool	connect (const std::string &hostName, unsigned int port, const HLTMainLoop &mainLoop)
bool	initialized () const
void	deinitialize ()

Private Member Functions
int	read_data (char *data, int len)
int	write_data (char *data, int len)
void	close (int socket)

Private Attributes
int	m_socket = -1
int	m_listener = -1
bool	m_initialized = false

Detailed Description

Definition at line 20 of file HLTSocket.h.

Constructor & Destructor Documentation

~HLTSocket()

~HLTSocket ( )

virtual

Definition at line 25 of file HLTSocket.cc.

{
  close(m_listener);
  close(m_socket);
  m_initialized = false;
}

Member Function Documentation

accept()

bool accept

(

unsigned int

port

)

Definition at line 188 of file HLTSocket.cc.

{
  // Before going on make sure to close the old socket
  close(m_socket);
 
  // Initialize the first listener
  if (m_listener <= 0) {
    B2RESULT("Started listening for new clients");
    struct sockaddr_in sa;
    bzero(&sa, sizeof(struct sockaddr_in));
 
    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);
 
    if ((m_listener = ::socket(AF_INET, SOCK_STREAM, 0)) < 0) {
      B2ERROR("Socket initialization failed: " << strerror(errno));
      return false;
    }
 
    int optval = 1;
    setsockopt(m_listener, SOL_SOCKET, SO_REUSEADDR, &optval, 4);
 
    int sizeval = D2_SOCKBUF_SIZE;
    setsockopt(m_listener, SOL_SOCKET, SO_SNDBUF, &sizeval, 4);
    setsockopt(m_listener, SOL_SOCKET, SO_RCVBUF, &sizeval, 4);
 
    signal(SIGPIPE, SIG_IGN);
 
    if ((bind(m_listener, (struct sockaddr*) &sa, sizeof(sa))) < 0) {
      B2ERROR("Socket binding failed: " << strerror(errno));
      return false;
    }
 
    listen(m_listener, 3);
  }
 
  struct sockaddr_in isa;
  socklen_t i = sizeof(isa);
  getsockname(m_listener, (struct sockaddr*)&isa, &i);
 
  B2RESULT("Started accepting new clients");
  if ((m_socket =::accept(m_listener, (struct sockaddr*)&isa, &i)) < 0) {
    B2ERROR("Socket accepting failed: " << strerror(errno));
    return false;
  }
 
  B2RESULT("Accepted connection with socket: " << m_socket);
  m_initialized = true;
  return true;
}

close()

void close ( int  socket )

private

Definition at line 239 of file HLTSocket.cc.

{
  if (socket > 0) {
    shutdown(socket, 2);
    ::close(socket);
    B2RESULT("Socket closed: " << socket);
  }
}

connect()

bool connect	(	const std::string &	hostName,
		unsigned int	port,
		const HLTMainLoop &	mainLoop
	)

Definition at line 248 of file HLTSocket.cc.

{
  // Before going on make sure to close the old socket
  close(m_socket);
 
  struct hostent* hp;
  if ((hp = gethostbyname(hostName.c_str())) == NULL) {
    B2ERROR("Host not found: " << strerror(errno));
    return false;
  }
 
  struct sockaddr_in sa;
  bzero(&sa, sizeof(sa));
  bcopy(hp->h_addr, (char*) &sa.sin_addr, hp->h_length);
  sa.sin_family = hp->h_addrtype;
  sa.sin_port = htons((u_short) port);
 
  if ((m_socket = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0) {
    B2ERROR("Socket initialization failed: " << strerror(errno));
    return false;
  }
 
  int sizeval = D2_SOCKBUF_SIZE;
  setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, &sizeval, 4);
  setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, &sizeval, 4);
  int yes = 1;
  setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, &yes, 4);
 
  signal(SIGPIPE, SIG_IGN);
 
  using namespace std::chrono_literals;
 
  int maxretry = 0;
  while (::connect(m_socket, (struct sockaddr*) &sa, sizeof(sa)) < 0) {
    if (errno == ETIMEDOUT or errno == ECONNREFUSED) {
      B2WARNING("Connection failed, will retry in 1 second... " << maxretry);
      std::this_thread::sleep_for(1s);
    } else {
      B2ERROR("Socket initialization failed: " << strerror(errno));
      return false;
    }
 
    if (not mainLoop.isRunning()) {
      return false;
    }
    maxretry++;
  }
 
  B2RESULT("Connected with socket: " << m_socket);
  m_initialized = true;
  return true;
}

deinitialize()

void deinitialize

(

)

Definition at line 305 of file HLTSocket.cc.

{
  m_initialized = false;
}

get()

int get	(	char *	data,
		int	len
	)

Definition at line 103 of file HLTSocket.cc.

{
  int gcount;
  const int br = read_data((char*) &gcount, 4);
  if (br < 0) {
    B2ERROR("Error in getting the size: " << strerror(errno));
    return br;
  } else if (br == 0) {
    B2WARNING("No data from socket!");
    return 0;
  }
 
  gcount = ntohl(gcount);
  if (gcount > len) {
    B2ERROR("buffer too small! " << gcount << " < " << len);
    return -1;
  }
  const int bcount = read_data(data, gcount);
  if (bcount < 0) {
    B2ERROR("Error in getting the data: " << strerror(errno));
    return bcount;
  } else if (bcount == 0) {
    B2WARNING("No data from socket!");
    return 0;
  }
  B2ASSERT("Read buffer size != buffer size in data!", bcount == gcount);
  return bcount;
}

get_wordbuf()

int get_wordbuf	(	int *	data,
		int	len
	)

Definition at line 132 of file HLTSocket.cc.

{
  int br = read_data((char*) wrdbuf, sizeof(int));
  if (br < 0) {
    B2ERROR("Error in getting the size: " << strerror(errno));
    return br;
  } else if (br == 0) {
    B2WARNING("No data from socket!");
    return 0;
  }
 
  const int gcount = (wrdbuf[0] - 1) * sizeof(int);
  if (gcount > len) {
    B2ERROR("buffer too small! " << gcount << " < " << len);
    return -1;
  }
  // ATTENTION: the send size is size / 4
  const int bcount = read_data((char*) &wrdbuf[1], gcount);
  if (bcount < 0) {
    B2ERROR("Error in getting the data: " << strerror(errno));
    return bcount;
  } else if (bcount == 0) {
    B2WARNING("No data from socket!");
    return 0;
  }
 
  B2ASSERT("Read buffer size != buffer size in data: " << bcount << " != " << gcount, bcount == gcount);
  return (wrdbuf[0]);
}

initialized()

bool initialized

(

)

const

Definition at line 301 of file HLTSocket.cc.

{
  return m_initialized;
}

put()

int put	(	char *	data,
		int	len
	)

Definition at line 32 of file HLTSocket.cc.

{
  const int to_size = htonl(len);
  const int br = write_data((char*) &to_size, sizeof(int));
  if (br == 0) {
    B2ERROR("Can not write to broken pipe.");
    return 0;
  } else if (br < 0) {
    B2ERROR("Error in sending the size: " << strerror(errno));
    return br;
  }
  const int bcount = write_data(data, len);
  if (bcount == 0) {
    B2ERROR("Can not write to broken pipe.");
    return 0;
  } else if (bcount < 0) {
    B2ERROR("Error in sending the data: " << strerror(errno));
    return bcount;
  }
  B2ASSERT("Written buffer size != buffer size in data!", bcount == len);
  return bcount;
}

put_wordbuf()

int put_wordbuf	(	int *	data,
		int	len
	)

Definition at line 55 of file HLTSocket.cc.

{
  // TODO: it is implicitly assumed that the first entry in the buffer is the buffer size!
  const int gcount = data[0];
  B2ASSERT("The first entry in the data must be the buffer size!", gcount == len);
 
  int bcount = write_data((char*) data, len * sizeof(int));
  if (bcount == 0) {
    B2ERROR("Can not write to broken pipe.");
    return 0;
  } else if (bcount < 0) {
    B2ERROR("Error in sending the data: " << strerror(errno));
    return bcount;
  }
  bcount = ((bcount - 1) / sizeof(int) + 1);
 
  B2ASSERT("Written buffer size != buffer size in data!", bcount == len);
 
  // ATTENTION: the returned size is size / 4
  return bcount;
}

read_data()

int read_data ( char *  data, int  len  )

private

Definition at line 162 of file HLTSocket.cc.

{
  char* buf = data;
  int bcount = 0;
 
  while (bcount < len) {
    int br = 0;
    if ((br = ::read(m_socket, buf, len - bcount)) > 0) {
      bcount += br;
      buf += br;
    }
    if (br == 0) return 0;
    if (br < 0) {
      switch (errno) {
        case EINTR:
          return -1;
        case EAGAIN:
          continue;
        default:
          return -1;
      }
    }
  }
  return bcount;
}

write_data()

int write_data ( char *  data, int  len  )

private

Definition at line 77 of file HLTSocket.cc.

{
  errno = 0;
  char* ptr = data;
  int bcount = 0;
 
  while (bcount < len) {
    int br = 0;
    if ((br = ::write(m_socket, ptr, len - bcount)) > 0) {
      bcount += br;
      ptr += br;
    }
    if (br < 0) {
      switch (errno) {
        case EINTR:
          return -1;
        case EPIPE:
          return 0;        // connection closed, sigpipe
        default:
          return -1;
      }
    }
  }
  return bcount;
}

Member Data Documentation

m_initialized

bool m_initialized = false

private

Definition at line 42 of file HLTSocket.h.

m_listener

int m_listener = -1

private

Definition at line 41 of file HLTSocket.h.

m_socket

int m_socket = -1

private

Definition at line 40 of file HLTSocket.h.

---

The documentation for this class was generated from the following files:

• daq/rfarm/event/hltsocket/include/HLTSocket.h
• daq/rfarm/event/hltsocket/src/HLTSocket.cc