Connection.cpp

Go to the documentation of this file.

/*

$Header$

*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <netdb.h>
#include <fcntl.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <net/if.h>

#include "Error.h"
#include "Memory.h"
#include "Core.h"

#include "Connection.h"

// Public methods.

Connection::Connection(const int socket, struct sockaddr_in *addr) : Socket(socket)
{
  int res;

  if (FAILED(res = setup(socket, addr)))
    failure(ERROR_BACKTRACE(res));
}

Connection::Connection() : Socket()
{
}

Connection::~Connection()
{
  int res;

  if (FAILED(res = CORE()->remove(this)))
    ERROR_BACKTRACE(res);
  if (_socket >= 0) {
    if (FAILED(res = shutdown(SHUT_RDWR)))
      ERROR_BACKTRACE(res);
    if (FAILED(res = close()))
      ERROR_BACKTRACE(res);
  }
}

int Connection::shutdown(const int how)
{
  if (::shutdown(_socket, how) != 0)
    return ERROR(MSG_SOCKET_CANNOT_SHUTDOWN, strerror(errno));

  return OK;
}

int Connection::close()
{
  if (::close(_socket) != 0)
    return ERROR(MSG_SOCKET_CANNOT_CLOSE, strerror(errno));
  _socket = -1;

  EMIT(closed);

  return OK;
}

String Connection::localIp() const
{
  return _localIp;
}

String Connection::peerIp() const
{
  return _peerIp;
}

unsigned int Connection::localPort() const
{
  return _localPort;
}

unsigned int Connection::peerPort() const
{
  return _peerPort;
}

int Connection::available(int &size)
{
  if (ioctl(_socket, FIONREAD, &size) < 0)
    return ERROR(MSG_SOCKET_CANNOT_GET_INFO, strerror(errno));

  return OK;
}

int Connection::read(char *buffer, const unsigned int size, const unsigned int triesNum)
{
  int actuallyRead, bytesToRead;
  int availableSize;
  unsigned int tries = 0;
  unsigned int bytesRead = 0;
  socklen_t peerLen = sizeof(_peer);
  int res;

//  DEBUG("Reading data from socket...");

  while (bytesRead != size) {
    errno = 0;
    if (FAILED(res = available(availableSize)))
      return ERROR_BACKTRACE(res);
    if (availableSize <= 0) {
      if (triesNum != 0) {
        ++tries;
        if (tries >= triesNum)
          return ERROR(MSG_SOCKET_CANNOT_READ, strerror(errno));
      }
      usleep(CONNECTION_SLEEP_TIME);
      continue;
    }
    if ((bytesToRead = size - bytesRead) > availableSize)
      bytesToRead = availableSize;

    if ((actuallyRead = recvfrom(_socket, buffer + bytesRead, bytesToRead, 0, (struct sockaddr *)&_peer, &peerLen)) <= 0)
      return ERROR(MSG_SOCKET_CANNOT_READ, strerror(errno));
    bytesRead += actuallyRead;
  }

  return OK;
}

int Connection::readAvailable(char *buffer, const unsigned int maxSize, int &actuallyRead)
{
  socklen_t peerLen = sizeof(_peer);

  errno = 0;
  if ((actuallyRead = recvfrom(_socket, buffer, maxSize, 0, (struct sockaddr *)&_peer, &peerLen)) < 0)
    return ERROR(MSG_SOCKET_CANNOT_READ, strerror(errno));

  return OK;
}

int Connection::readLn(String &buffer, const unsigned int maxSize, const unsigned int triesNum)
{
  int actuallyRead;
  unsigned int tries = 0;
  unsigned int bytesRead = 0;
  unsigned char c;
  socklen_t peerLen = sizeof(_peer);

  buffer = "";
  while (1) {
    errno = 0;
    while ((actuallyRead = recvfrom(_socket, &c, 1, 0, (struct sockaddr *)&_peer, &peerLen)) <= 0 && errno == EAGAIN) {
      usleep(CONNECTION_SLEEP_TIME);
      errno = 0;
      if (triesNum > 0) {
        ++tries;
        if (tries >= triesNum && bytesRead == 0)
          return OK;
      }
    }
    if (actuallyRead > 0) {
      bytesRead += actuallyRead;
      if (bytesRead >= maxSize - 1)
        break;
      if (c != '\n' && c != '\r')
        buffer += c;
      if (c == '\n')
        break;
    } else
        if (bytesRead == 0)
          return actuallyRead < 0 ? ERROR(MSG_SOCKET_CANNOT_READ, strerror(errno)) : OK;
        else
          break;
  }

  return OK;
}

int Connection::write(const char *data, const unsigned int size, int &actuallyWritten)
{
  if ((actuallyWritten = sendto(_socket, data, size, 0, (struct sockaddr *)&_peer, sizeof(_peer))) < 0)
    return errno != EAGAIN ? ERROR(MSG_SOCKET_CANNOT_WRITE, strerror(errno)) : OK;

  return OK;
}

int Connection::writeStr(const String &str)
{
  int actuallyWritten;
  unsigned int len = str.length();
  int res;

//  DEBUG("Writing to socket: '%s'.", str.c_str());
  if (FAILED(res = write(CSTRING(str), len, actuallyWritten)))
    return ERROR_BACKTRACE(res);

  if (actuallyWritten != (int)len)
    return ERROR(MSG_SOCKET_CANNOT_WRITE, strerror(errno));

  return OK;
}

int Connection::writeStr(char *str)
{
  int actuallyWritten;
  unsigned int len = strlen(str);
  int res;

//  DEBUG("Writing to socket: '%s'.", str);
  if (FAILED(res = write(str, len, actuallyWritten)))
    return ERROR_BACKTRACE(res);

  if (actuallyWritten != (int)len)
    return ERROR(MSG_SOCKET_CANNOT_WRITE, strerror(errno));

  return OK;
}

int Connection::writeLn(char *data, const char *eol)
{
  int actuallyWritten;
  unsigned int len = strlen(data);
  int res;

  if (FAILED(res = write(data, len, actuallyWritten)))
    return ERROR_BACKTRACE(res);
  if (actuallyWritten != (int)len)
    return ERROR(MSG_SOCKET_CANNOT_WRITE, strerror(errno));

  if (eol) {
    len = strlen(eol);
    res = write(eol, len, actuallyWritten);
  } else {
      len = strlen(String::eol());
      res = write(String::eol(), len, actuallyWritten);
    }
  if (FAILED(res))
    return ERROR_BACKTRACE(res);

  if (actuallyWritten != (int)len)
    return ERROR(MSG_SOCKET_CANNOT_WRITE, strerror(errno));

  return OK;
}

int Connection::vprintf(const char *format, va_list ap)
{
  String msg;
  int res;

  msg.vsprintf(format, ap);
  if (FAILED(res = writeStr(msg)))
    return ERROR_BACKTRACE(res);

  return OK;
}

int Connection::printf(const char *format, ...)
{
  va_list ap;
  int res;

  va_start(ap, format);
  res = vprintf(format, ap);
  va_end(ap);

  if (FAILED(res))
    return ERROR_BACKTRACE(res);

  return OK;
}

int Connection::isAlive(bool &yes)
{
  char ready;
  socklen_t peerLen = sizeof(_peer);
  ssize_t res;

  errno = 0;
  res = recvfrom(_socket, &ready, 1, MSG_PEEK, (struct sockaddr *)&_peer, &peerLen);
  yes = (res > 0 || res < 0 && errno == EAGAIN);

  return OK;
}

int Connection::clear()
{
  char buff[LIMIT_CSTRING_SIZE];
  socklen_t peerLen = sizeof(_peer);
  int size, actuallyRead;
  unsigned int bytesRead = 0, bytesToRead;
  int res;

  if (FAILED(res = available(size)))
    return ERROR_BACKTRACE(res);

  if (size <= 0)
    return OK;

  while ((int)bytesRead < size) {
    if ((bytesToRead = size - (int)bytesRead) > sizeof(buff))
      bytesToRead = sizeof(buff);
    if ((actuallyRead = recvfrom(_socket, buff, bytesToRead, 0, (struct sockaddr *)&_peer, &peerLen)) < 0)
      break;
    bytesRead += actuallyRead;
  }

  return OK;
}

int Connection::setAddress(const char *host, const char *service, const char *protocol, struct sockaddr_in *sap)
{
  struct servent *sp;
  struct hostent *hp;
  char *endptr;
  short port;

  bzero(sap, sizeof(*sap));
  sap->sin_family = AF_INET;
  if (host && strlen(host)) {
    if (!inet_aton(host, &sap->sin_addr)) {
      hp = gethostbyname(host);
      if (hp == NULL)
        return ERROR(MSG_SOCKET_UNKNOWN_HOST, host);
      sap->sin_addr = *(struct in_addr *)hp->h_addr;
    }
  } else
      sap->sin_addr.s_addr = htonl(INADDR_ANY);

  port = strtol(service, &endptr, 0);
  if (*endptr == '\0')
    sap->sin_port = htons(port);
  else {
    sp = getservbyname(service, protocol);
    if (sp == NULL)
      return ERROR(MSG_SOCKET_UNKNOWN_SERVICE, service);
    sap->sin_port = sp->s_port;
  }

  return OK;
}

int Connection::localIp(String &ip)
{
  struct ifreq ifReq;
  int sock;

  memset(&ifReq, 0, sizeof(ifReq));
  strcpy(ifReq.ifr_name, CONNECTION_DEFAULT_INT_NAME);

  if ((sock = ::socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    return ERROR(MSG_SOCKET_CANNOT_CREATE, strerror(errno));

  if (ioctl(sock, SIOCGIFADDR, &ifReq) != 0) {
    ::close(sock);
    return ERROR(MSG_SOCKET_CANNOT_GET_INFO, strerror(errno));
  }

  ip = inet_ntoa(((struct sockaddr_in *)&ifReq.ifr_addr)->sin_addr);

  if (::close(sock) != 0)
    return ERROR(MSG_SOCKET_CANNOT_CLOSE, strerror(errno));

  return OK;
}

// Protected methods.

int Connection::setup(const int socket, struct sockaddr_in *addr)
{
  socklen_t localLen;
  int res;

  _socket = socket;
  _peer = *addr;
  localLen = sizeof(_local);
  getsockname(_socket, (struct sockaddr *)&(_local), &localLen);

  _localIp = inet_ntoa(_local.sin_addr);
  _localPort = ntohs(_local.sin_port);
  _peerIp = inet_ntoa(_peer.sin_addr);
  _peerPort = ntohs(_peer.sin_port);

  if (FAILED(res = CORE()->add(this)))
    return ERROR_BACKTRACE(res);

  return OK;
}

int Connection::setDataReady()
{
  EMIT(dataReady);
  return OK;
}

int Connection::setDead()
{
  _socket = -1;
  EMIT(dead);
  return OK;
}

---