---

socket.hpp

Go to the documentation of this file.

/*
 * Equation Cruncher
 * Copyright (C) 2004  Dhruv Matani(dhruvbird@yahoo.com)
 * 
 * 
 * This program 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; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */


#if !defined EC_SOCKET_HPP
#define EC_SOCKET_HPP


// Standard UNIX headers.
#include <sys/types.h> 
#include <netinet/in.h> 
#include <arpa/inet.h>
#include <sys/socket.h> 
#include <sys/wait.h>
#include <unistd.h>
#include <netdb.h>

// Standard C++ headers.
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <exception>
#include <stdexcept>
#include <sstream>
#include <string>
#include <assert.h>

namespace eqn_cruncher
{
  class socket_error : public std::runtime_error
  {
  public:
    socket_error(std::string const& _reason)
      : std::runtime_error(_reason)
    { }


    socket_error()
      : std::runtime_error("socket_error")
    { }
  };


  class host_error : public socket_error
  {
  public:
    host_error(std::string const& _reason)
      : socket_error(_reason)
    { }

    host_error()
      : socket_error("host_error")
    { }
  };


  class port_error : public socket_error
  {
  public:
    port_error(std::string const& _reason)
      : socket_error(_reason)
    { }


    port_error()
      : socket_error("port_error")
    { }
  };


  class socket
  {
    int sock_id;

  public:
    typedef std::pair<sockaddr_in, int> accept_t;

    int
    get_sockid() { return this->sock_id; }


    static
    sockaddr_in
    get_socket_info(unsigned short int port_no)
    {
      sockaddr_in temp;
      temp.sin_family = AF_INET;          // host byte order.
      temp.sin_port = htons(port_no);     // short, network byte order.
      temp.sin_addr.s_addr = INADDR_ANY;  // auto-fill with my IP.
      bzero(&(temp.sin_zero), 8);         // zero the rest of the struct.
      return temp;
    }


    static
    hostent*
    host_by_name(std::string const& host_name)
    {
      hostent* temp = gethostbyname(host_name.c_str());
      if (temp == NULL)
        throw host_error("Error looking up Host Name...");
      return temp;
    }


    static
    std::string
    str_ip(unsigned int uint_ip)
    {
      typedef unsigned int uint;
      uint mask = 255;
      mask <<= 24;
      std::ostringstream os;
      os<<((uint_ip & mask)>>24)<<'.';
      mask >>= 8;
      os<<((uint_ip & mask)>>16)<<'.';
      mask >>= 8;
      os<<((uint_ip & mask)>>8)<<'.';
      mask >>= 8;
      os<<(uint_ip & mask);
      return os.str();
    }


    socket() : sock_id(0)
    {
      sock_id = ::socket(AF_INET, SOCK_STREAM, 0);
      if (sock_id == -1)
        throw socket_error("Error creating socket!");
    }


    explicit
    socket(const int _sockid)
    {
      assert(_sockid != -1);
      sock_id = _sockid;
    }


    std::string
    get_remote_name()
    {
      sockaddr_in temp;
      socklen_t tsize = sizeof(sockaddr_in);
      ::getpeername(this->sock_id, reinterpret_cast<sockaddr*>(&temp), &tsize);
      return str_ip(ntohl(temp.sin_addr.s_addr));
    }


    void
    reuse_sock_addr()
    {
      volatile int opts = 1;
      ::setsockopt(this->sock_id, SOL_SOCKET, SO_REUSEADDR, 
                   (void*)&opts, sizeof(opts));
    }


    void
    bind(unsigned short int _pno)
    {
      sockaddr_in temp = get_socket_info(_pno);
      if (::bind(sock_id, reinterpret_cast<sockaddr*>(&temp), sizeof(sockaddr)) == -1)
        {
          std::ostringstream port_str;
          port_str<<_pno;
          throw port_error("Error Binding to Port: " + port_str.str());
        }
    }


    void
    connect(unsigned short int _pno, std::string const& host_name)
    {
      sockaddr_in temp = get_socket_info(_pno);
      hostent* thost = host_by_name(host_name);

      memcpy(&temp.sin_addr, thost->h_addr, thost->h_length);

      if (::connect(sock_id, reinterpret_cast<sockaddr*>(&temp), sizeof(sockaddr)) == -1)
        throw socket_error("Error Connecting to Host: " + host_name);
    }


    void
    listen(int max_queued = 10)
    {
      if (::listen(sock_id, max_queued) == -1)
        throw socket_error("Error while listening on Socket!");
    }


    accept_t
    accept()
    {
      sockaddr_in temp;
      int ret_size = sizeof(sockaddr_in);
      int new_sock_id = ::accept(sock_id, reinterpret_cast<sockaddr*>(&temp), 
                                 reinterpret_cast<socklen_t*>(&ret_size));
      if (new_sock_id == -1)
        throw socket_error("Error accepting Connection!");

      return std::make_pair(temp, new_sock_id);
    }


    int
    send(const char* buff, int buff_len)
    {
      int bytes_sent = 
        ::send(sock_id, buff, buff_len, 0);

      if (bytes_sent == -1)
        throw socket_error("Send Error!");
      return bytes_sent;
    }


    int
    send(std::string const& data)
    {
      return this->send(data.data(), data.size());
    }


    int
    sendto(const char* buff, int len, std::string const& host_name)
    {
      sockaddr_in temp = get_socket_info(0);
      temp.sin_addr = *(reinterpret_cast<in_addr*>(host_by_name(host_name)->h_addr));

      int bytes_sent = 
        ::sendto(sock_id, buff, len, 0, reinterpret_cast<sockaddr*>(&temp), 
                 sizeof(sockaddr));
      if (bytes_sent == -1)
        throw socket_error("SendTo Error!");

      return bytes_sent;
    }


    int
    sendto(std::string const& msg, std::string const& host_name)
    {
      return this->sendto(msg.data(), msg.size(), host_name);
    }


    int
    receive(void* buff, int buff_size)
    {
      int retval = ::recv(sock_id, buff, buff_size, 0);
      if (retval == -1)
        throw socket_error("Error Receiving data!");
      return retval;
    }


    int
    receive_from(void* buff, int buff_size)
    {
      sockaddr temp;
      socklen_t temp_len = sizeof(temp);
      int retval = 
        ::recvfrom(sock_id, buff, buff_size, 0, &temp, &temp_len);
      if (retval == -1)
        throw socket_error("Error Receiving data!");
      return retval;
    }


    void
    close()
    {
      ::shutdown(sock_id, SHUT_RDWR);
    }
  };
}

#endif // EC_SOCKET_HPP

---