connection.cc

/*
  This file is part of SLL.
  Copyright (C) 2008 Sebastien LUTTRINGER <contact@seblu.net>

  SLL is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; version 2 of the License.

  SLL is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with SLL; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "slm.hh"
#include "connection.hh"
#include "error.hh"

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <errno.h>
#include <poll.h>

/*******************************************************************************
 ** Class method
 ******************************************************************************/
unsigned long int Connection::getconnid() {
  static unsigned long int id = 1;
  return id++;
}

/*******************************************************************************
 ** Public method
 ******************************************************************************/

/**
 * Constructor
 *
 * @param fd socket of the connection (-1) is not exist
 */
Connection::Connection(int fd) : socket_fd_(fd), local_port_(-1), remote_port_(-1), id_(0) {
  pthread_mutex_init(&c_mutex_, 0);
  pthread_mutex_init(&r_mutex_, 0);
  pthread_mutex_init(&w_mutex_, 0);

  if (socket_fd_ >= 0) {
    id_ = getconnid();
    setallinfo_();
  }
}

/**
 * Destructor
 */
Connection::~Connection() {
  pthread_mutex_destroy(&c_mutex_);
  pthread_mutex_destroy(&r_mutex_);
  pthread_mutex_destroy(&w_mutex_);
}

/**
 * Create connection with @param addr on port @param port
 */
void Connection::connect(const char *addr, int port) {
 if (socket_fd_ >= 0)
    throw Error(ERR_NET, "Connection already established but trying to connect");

 if (port <= 0)
    throw Error(ERR_NET, "Trying to Connect on a bad port number");

  pthread_mutex_lock(&c_mutex_);
  pthread_mutex_lock(&r_mutex_);
  pthread_mutex_lock(&w_mutex_);

  // retrieve remote host info
  struct hostent *h = gethostbyname(addr);
  if (h == 0) {
    pthread_mutex_unlock(&w_mutex_);
    pthread_mutex_unlock(&r_mutex_);
    pthread_mutex_unlock(&c_mutex_);
    throw Error(ERR_NET, (string) "Unable to resolve: " + addr  + ": " + hstrerror(h_errno));
  }

  // create socket
  try { socket_(); }
  catch (...) {
    pthread_mutex_unlock(&w_mutex_);
    pthread_mutex_unlock(&r_mutex_);
    pthread_mutex_unlock(&c_mutex_);
    throw;
  }

  // fill sockaddr
  struct sockaddr_in daddr;
  daddr.sin_family = AF_INET;
  daddr.sin_port = htons(port);
  daddr.sin_addr = *((struct in_addr *) h->h_addr);
  memset(daddr.sin_zero, '\0', sizeof daddr.sin_zero);

  // connect
  if (::connect(socket_fd_, (struct sockaddr *) &daddr, sizeof daddr) == -1) {
    disconnect_();
    pthread_mutex_unlock(&w_mutex_);
    pthread_mutex_unlock(&r_mutex_);
    pthread_mutex_unlock(&c_mutex_);
    throw Error(ERR_NET, (string) "Unable to connect to " + addr  + ": " + hstrerror(h_errno));
  }

  // set infos
  setallinfo_();

  pthread_mutex_unlock(&w_mutex_);
  pthread_mutex_unlock(&r_mutex_);
  pthread_mutex_unlock(&c_mutex_);
}

/**
 * Listen on @param port with queue size of max @param max
 */
void Connection::listen(int port, int max) {
  if (socket_fd_ >= 0)
    throw Error(ERR_NET, "Connection already established but trying to listen");

  // lock
  pthread_mutex_lock(&c_mutex_);
  pthread_mutex_lock(&r_mutex_);
  pthread_mutex_lock(&w_mutex_);

  // create socket
  try { socket_(); }
  catch (...) {
    pthread_mutex_unlock(&w_mutex_);
    pthread_mutex_unlock(&r_mutex_);
    pthread_mutex_unlock(&c_mutex_);
    throw;
  }

  // fill sockaddr
  struct sockaddr_in saddr;

  saddr.sin_family = AF_INET;
  saddr.sin_port = htons(port);
  saddr.sin_addr.s_addr = INADDR_ANY;
  memset(saddr.sin_zero, '\0', sizeof saddr.sin_zero);

  // bind on socket
  if (bind(socket_fd_, (struct sockaddr *)&saddr, sizeof saddr) == -1) {
    disconnect_();
    pthread_mutex_unlock(&w_mutex_);
    pthread_mutex_unlock(&r_mutex_);
    pthread_mutex_unlock(&c_mutex_);
    throw Error(ERR_NET, (string) "Unable to bind: " + strerror(errno));
  }

  // listen on socket
  if (::listen(socket_fd_, max) == -1) {
    disconnect_();
    pthread_mutex_unlock(&w_mutex_);
    pthread_mutex_unlock(&r_mutex_);
    pthread_mutex_unlock(&c_mutex_);
    throw Error(ERR_NET, (string) "Unable to listen: " + strerror(errno));
  }

  // set all infos
  setallinfo_();

  pthread_mutex_unlock(&w_mutex_);
  pthread_mutex_unlock(&r_mutex_);
  pthread_mutex_unlock(&c_mutex_);
}

/**
 * Disconnect socket
 */
void Connection::disconnect() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to disconnect");

  // lock all mutex
  pthread_mutex_lock(&c_mutex_);
  pthread_mutex_lock(&r_mutex_);
  pthread_mutex_lock(&w_mutex_);

  disconnect_();

  pthread_mutex_unlock(&w_mutex_);
  pthread_mutex_unlock(&r_mutex_);
  pthread_mutex_unlock(&c_mutex_);
}

/**
 * Return the connection sate
 * Cannot be const, du to mutex locking
 *
 * @return see description
 */
bool Connection::connected() {
  // get connection mutex

  pthread_mutex_lock(&c_mutex_);

  bool ret = (socket_fd_ >= 0);

  pthread_mutex_unlock(&c_mutex_);

  return ret;
}

/**
 * Accept new connection on a listening socket
 *
 * @return null on error, else a new connection
 */
Connection *Connection::accept() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to accept");

  struct sockaddr_in r_addr;
  socklen_t r_sin_size = sizeof r_addr;
  int r_fd;

  pthread_mutex_lock(&r_mutex_);
  pthread_mutex_lock(&w_mutex_);

  if ((r_fd = ::accept(socket_fd_, (struct sockaddr *) &r_addr, &r_sin_size)) == -1) {
    pthread_mutex_unlock(&c_mutex_);
    throw Error(ERR_NET, (string) "accept: " + strerror(errno));
  }

  pthread_mutex_unlock(&r_mutex_);
  pthread_mutex_unlock(&w_mutex_);

  return new Connection(r_fd);
}

/**
 * Send data on @param buf of size @param len on socket
 */
void Connection::send(const char* buf, size_t len) {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to send data");

  pthread_mutex_lock(&w_mutex_);
  int ret = ::send(socket_fd_, buf, len, 0);
  pthread_mutex_unlock(&w_mutex_);

  if (ret == -1 && errno == ECONNRESET)
    throw Error(ERR_NET, "Connection reset by peer");
  if (ret == -1)
    throw Error(ERR_NET, "send: " + (string) strerror(errno));
}

/**
 * Send data on @param buf of size @param len followed by '\n' on socket
 */
void Connection::sendln(const char* buf, size_t len) {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to send line");

  pthread_mutex_lock(&w_mutex_);
  // write data
  int ret = ::send(socket_fd_, buf, len, 0);
  if (ret == -1) {
    pthread_mutex_unlock(&w_mutex_);
    if (errno == ECONNRESET)
      throw Error(ERR_NET, "Connection reset by peer");
    throw Error(ERR_NET, "sendln: " + (string) strerror(errno));
  }

  // write '\n'
  ret = ::send(socket_fd_, "\n", 1, 0);
  pthread_mutex_unlock(&w_mutex_);
  if (ret == -1)
    throw Error(ERR_NET, "sendln: " + (string) strerror(errno));
}

/**
 * Receive a line
 */
string Connection::recvln() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to receive line");

  pthread_mutex_lock(&r_mutex_);
  do {
    // check EOL char
    size_t offset = rbuf_.find('\n');
    if (offset != string::npos) {
      string s = rbuf_.substr(0, offset);
      rbuf_.erase(0, offset + 1);
      pthread_mutex_unlock(&r_mutex_);
      return s;
    }

    // do poll fd here ?

    // read data
    static char local_buf[MAX_LINE_SIZE];
    int ret = ::recv(socket_fd_, local_buf, MAX_LINE_SIZE, 0);

    if (ret == 0) {
      pthread_mutex_unlock(&r_mutex_);
      throw Error(ERR_NET, "Connection reset by peer");
    }

    if (ret == -1) {
      *local_buf = 0;

      // unlock before error
      pthread_mutex_unlock(&r_mutex_);

      throw Error(ERR_NET, (string) "recvln: " + strerror(errno));
    }
    else local_buf[ret] = 0;

    // add read data in buffer
    rbuf_ += local_buf;

  } while (1);
  assert(1);
}

string Connection::getlocalip() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to get local ip");

  pthread_mutex_lock(&c_mutex_);
  if (local_ip_.empty())
    setlocalip_();
  string ip = local_ip_;
  pthread_mutex_unlock(&c_mutex_);
  return ip;
}

int Connection::getlocalport() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to get local port");

  pthread_mutex_lock(&c_mutex_);
  if (local_port_ == -1)
    setlocalport_();
  int port = local_port_;
  pthread_mutex_unlock(&c_mutex_);
  return port;
}

string Connection::getremoteip() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to get remote ip");

  pthread_mutex_lock(&c_mutex_);
  if (remote_ip_.empty())
    setremoteip_();
  string ip = remote_ip_;
  pthread_mutex_unlock(&c_mutex_);
  return ip;
}

int Connection::getremoteport() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to get remote port");

  pthread_mutex_lock(&c_mutex_);
  if (remote_port_ == -1)
    setremoteport_();
  int port = remote_port_;
  pthread_mutex_unlock(&c_mutex_);
  return port;
}

unsigned long int Connection::getid() {
  return id_;
}

int Connection::getsocket() {
  if (socket_fd_ < 0)
    throw Error(ERR_NET, "No connection established but trying to get socket fd");

  pthread_mutex_lock(&c_mutex_);
  int ret = socket_fd_;
  pthread_mutex_unlock(&c_mutex_);
  return ret;
}

/*******************************************************************************
 ** Protected method
 ******************************************************************************/

/**
 * Reserve a socket
 * No mutex used !
 */
void Connection::socket_() {
  assert(socket_fd_ == -1);
  int yes = 1;

  if ((socket_fd_ = ::socket(AF_INET, SOCK_STREAM, 0)) == -1)
    throw Error(ERR_NET, (string) "Unable to open socket: " + strerror(errno));

  if (::setsockopt(socket_fd_, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
    throw Error(ERR_NET, (string) "Unable to set socket options: " + strerror(errno));
}

/**
 * Free a socket
 * No mutex used !
 */
void Connection::disconnect_() {
  assert(socket_fd_ >= 0);

  close(socket_fd_);
  socket_fd_ = -1;
}

/**
 * Set local ip
 * No mutex used !
 */
void Connection::setlocalip_() {
  struct sockaddr_in addr;
  socklen_t len = sizeof addr;

  ::getsockname(socket_fd_, (struct sockaddr*) &addr, &len);
  local_ip_ = inet_ntoa(addr.sin_addr);
}

/**
 * Set local port
 * No mutex used !
 */
void Connection::setlocalport_() {
  struct sockaddr_in addr;
  socklen_t len = sizeof addr;

  ::getsockname(socket_fd_, (struct sockaddr*) &addr, &len);
  local_port_ = ntohs(addr.sin_port);
}

/**
 * Set remote ip
 * No mutex used !
 */
void Connection::setremoteip_() {
  struct sockaddr_in addr;
  socklen_t len = sizeof addr;

  ::getpeername(socket_fd_, (struct sockaddr*) &addr, &len);
  remote_ip_ = inet_ntoa(addr.sin_addr);
}

/**
 * Set remote port
 * No mutex used !
 */
void Connection::setremoteport_() {
  struct sockaddr_in addr;
  socklen_t len = sizeof addr;

  ::getpeername(socket_fd_, (struct sockaddr*) &addr, &len);
  remote_port_ = ntohs(addr.sin_port);
}