socket_traits_unix.hpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful
 
  CLAW is a free library without any particular aim but being useful to
  anyone.
 
  Copyright (C) 2005-2011 Julien Jorge
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
  contact: julien.jorge@stuff-o-matic.com
*/
#ifndef __CLAW_SOCKET_TRAITS_UNIX_HPP__
#define __CLAW_SOCKET_TRAITS_UNIX_HPP__
 
#include <claw/assert.hpp>
 
#include <cstring>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
namespace claw
{
  class socket_traits_unix
  {
  public:
    typedef int descriptor;
 
  public:
    static const descriptor invalid_socket = -1;
 
  public:
    static bool init()
    {
      return true;
    }

    static bool release()
    {
      return true;
    }

    static descriptor open()
    {
      descriptor fd = invalid_socket;
 
      fd = socket(AF_INET, SOCK_STREAM, 0);
 
      return fd;
    }

    static bool close(descriptor d)
    {
      return ::close(d) == 0;
    }

    static bool connect(descriptor d, const std::string& address, int port)
    {
      CLAW_PRECOND(d != invalid_socket);
 
      bool result = false;
      struct hostent* hp = gethostbyname(address.c_str());
 
      if(hp)
        {
          struct sockaddr_in sa;
 
          memset(&sa, '\0', sizeof(sa));
          sa.sin_family = hp->h_addrtype;
          sa.sin_port = htons(port);
          memcpy(&sa.sin_addr, hp->h_addr, hp->h_length);
 
          if(::connect(d, (struct sockaddr*)&sa, (socklen_t)sizeof(sa)) != -1)
            result = true;
        }
 
      return result;
    }

    static bool listen(descriptor d, int port, unsigned int queue_size)
    {
      CLAW_PRECOND(d != invalid_socket);
 
      struct sockaddr_in addr;
 
      memset(&addr, '\0', sizeof(addr));
      addr.sin_family = AF_INET;
      addr.sin_port = htons(port);
      addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
      if(bind(d, (struct sockaddr*)&addr, sizeof(addr)) != -1)
        return ::listen(d, queue_size) != -1;
      else
        return false;
    }

    static bool select_read(descriptor d, int time_limit = -1)
    {
      CLAW_PRECOND(d != invalid_socket);
 
      struct timeval tv, *ptv;
      fd_set fds;
 
      if(time_limit < 0)
        ptv = NULL;
      else
        {
          tv.tv_sec = time_limit;
          tv.tv_usec = 0;
 
          ptv = &tv;
        }
 
      FD_ZERO(&fds);
      FD_SET(d, &fds);
 
      select(d + 1, &fds, NULL, NULL, ptv);
 
      return FD_ISSET(d, &fds);
    }

    static descriptor accept(descriptor d)
    {
      return ::accept(d, NULL, NULL);
    }

    static bool valid_descriptor(descriptor d)
    {
      return d != invalid_socket;
    }

    static bool is_open(descriptor d)
    {
      struct stat buf;
 
      return fstat(d, &buf) == 0;
    }
 
  }; // class socket_traits_unix
 
  typedef socket_traits_unix socket_traits;
}
 
#endif // __CLAW_SOCKET_TRAITS_UNIX_HPP__