JSocket.hh

Go to the documentation of this file.

#ifndef __JNET__JSOCKET__
#define __JNET__JSOCKET__

#include <sys/socket.h>
#include <netdb.h>
#include <netinet/tcp.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <errno.h>
#include <string>

#include "JLang/JException.hh"
#include "JLang/JFile.hh"
#include "JSystem/JNetwork.hh"
#include "JNet/JSocketAddress.hh"


#define IPROTO_TCP 6


/**
 * \author mdejong
 */

/**
 * Interprocess communication.
 */
namespace JNET {}
namespace JPP { using namespace JNET; }

namespace JNET {

  using JLANG::JFile;
  using JLANG::JSocketException;
  using JSYSTEM::getHostname;
  using JSYSTEM::getIPnumber;
  using JSYSTEM::getIPaddress;


  /**
   * Socket class.
   */
  class JSocket :
    public JFile,
    public JSocketAddress
  {
  public:
    /**
     * Default constructor.
     */
    JSocket() :
      JFile()
    {}


    /**
     * Constructor.
     *
     * \param  type           socket type
     */
    JSocket(const int type) :
      JFile(socket(PF_INET, type, 0))
    {
      if (getFileDescriptor() < 0) {
        THROW(JSocketException, "Error opening socket.");
      }

      setFamily(AF_INET);
    }


    /**
     * Constructor.
     *
     * \param  domain         communication domain
     * \param  type           socket type
     * \param  protocol       protocol
     */
    JSocket(const int domain,
            const int type,
            const int protocol = 0) :
      JFile(socket(domain, type, protocol))
    {
      if (getFileDescriptor() < 0) {
        THROW(JSocketException, "Error opening socket.");
      }

      setFamily(domain);
    }


    /**
     * Shut down socket.
     */
    int shutdown()
    {
      const int value = ::shutdown(getFileDescriptor(), SHUT_RDWR);

      close();

      return value;
    }


    /**
     * Set non-blocking of I/O.
     *
     * \param  on             true to enable non-blocking; false to disable
     */
    void setNonBlocking(const bool on)
    {
      const int flags = fcntl(getFileDescriptor(), F_GETFL, -1);
      const int mask  = FNDELAY;

      if (flags == -1) {
        THROW(JSocketException, "Get socket option failed.");
      }

      if (((flags & mask) != mask &&  on) ||
          ((flags & mask) != 0    && !on) ) {

        if (fcntl(getFileDescriptor(), F_SETFL, flags ^ mask) < 0) {
          THROW(JSocketException, "Set socket option failed.");   
        }
      }
    }


    /**
     * Get non-blocking of I/O.
     *
     * \return                true if enabled non-blocking; else false
     */
    bool getNonBlocking() const
    {
      const int flags = fcntl(getFileDescriptor(), F_GETFL, -1);
      const int mask  = FNDELAY;

      if (flags == -1) {
        THROW(JSocketException, "Get socket option failed.");
      }

      return ((flags & mask) != 0);
    }


    /**
     * Set keep alive of socket.
     *
     * \param  on             true to enable keep alive; false to disable
     */
    void setKeepAlive(const bool on)
    {
      setOption(SOL_SOCKET, SO_KEEPALIVE, int(on ? 1 : 0));
    }


    /**
     * Get keep alive of socket.
     *
     * \return                true if keep alive; else false
     */
    bool getKeepAlive() const
    {
      return (getOption<int>(SOL_SOCKET, SO_KEEPALIVE) == 1);
    }


    /**
     * Set the TCP idle time.
     *
     * \param  t_s            time [s]
     */
    void setKeepIdle(const int t_s)
    {
      setOption(IPROTO_TCP, TCP_KEEPIDLE, t_s);
    }


    /**
     * Set the TCP idle count.
     *
     * \param  count          count
     */
    void setKeepCnt(const int count)
    {
      setOption(IPROTO_TCP, TCP_KEEPCNT, count);
    }


    /**
     * Set the TCP interval time.
     *
     * \param  t_s            time [s]
     */
    void setKeepIntvl(const int t_s)
    {
      setOption(IPROTO_TCP, TCP_KEEPINTVL, t_s);
    }


    /**
     * Set reuse address.
     *
     * \param  on             true to enable reuse address; false to disable
     */
    void setReuseAddress(const bool on)
    {
      setOption(SOL_SOCKET, SO_REUSEADDR, int(on ? 1 : 0));
    }


    /**
     * Get reuse address.
     *
     * \return                true if enable reuse address; else false
     */
    bool getReuseAddress() const
    {
      return (getOption<int>(SOL_SOCKET, SO_REUSEADDR) == 1);
    }


    /**
     * Set TCP no-delay.
     *
     * \param  on             true to set TCP no-delay; false to disable
     */
    void setTcpNoDelay(const bool on)
    {
      setOption(IPPROTO_TCP, TCP_NODELAY, int(on ? 1 : 0));
    }


    /**
     * Get TCP no-delay.
     *
     * \return                true if TCP no-delay; else false
     */
    bool getTcpNoDelay() const
    {
      return (getOption<int>(IPPROTO_TCP, TCP_NODELAY) == 1);
    }


    /**
     * Set receive buffer size.
     *
     * \param  size           number of bytes
     */
    void setReceiveBufferSize(const int size)
    {
      setOption(SOL_SOCKET, SO_RCVBUF, int(size));
    }


    /**
     * Set receive buffer size.
     *
     * \return                number of bytes
     */
    int getReceiveBufferSize() const
    {
      return getOption<int>(SOL_SOCKET, SO_RCVBUF);
    }


    /**
     * Set send buffer size.
     *
     * \param  size           number of bytes
     */
    void setSendBufferSize(const int size)
    {
      setOption(SOL_SOCKET, SO_SNDBUF, int(size));
    }


    /**
     * Get send buffer size.
     *
     * \return                number of bytes
     */
    int getSendBufferSize() const
    {
      return getOption<int>(SOL_SOCKET, SO_SNDBUF);
    }
    

    /**
     * Read data from socket.
     *
     * This method handles I/O errors in such a way that:
     *   -# the return value is set to zero if no data are read;
     *   -# an exception is thrown in case of a fatal error;
     *
     * \param  buffer       buffer
     * \param  length       number of bytes to read
     * \return              number of bytes actually read
     */
    virtual int read(char* buffer, const int length) override 
    {
      int pos = JFile::read(buffer, length);

      if        (pos == 0) {
        
        THROW(JSocketException, "Socket read failed.");
        
      } else if (pos <  0) {
        
        switch (errno) {
          
        case EINTR:
        case EWOULDBLOCK:
          //case EAGAIN:
          break;
          
        default:
          THROW(JSocketException, "Socket read error.");
        }

        pos = 0;
      }

      return pos;
    }
    

    /**
     * Write data to socket.
     *
     * This method handles I/O errors in such a way that:
     *   -# the return value is set to zero if no data are written;
     *   -# an exception is thrown in case of a fatal error;
     *
     * \param  buffer       buffer
     * \param  length       number of bytes to write
     * \return              number of bytes actually written
     */
    virtual int write(const char* buffer, const int length) override 
    {
      int pos = JFile::write(buffer, length);

      if        (pos == 0) {
        
        THROW(JSocketException, "Socket write failed.");
        
      } else if (pos <  0) {
        
        switch (errno) {
          
        case EINTR:
        case EWOULDBLOCK:
          //case EAGAIN:
          break;
          
        default:
          THROW(JSocketException, "Socket write error.");
        }

        pos = 0;
      }

      return pos;
    }


    /**
     * Accept connection from a server.
     *
     * \param  server         file descriptor of server socket
     */
    void accept(const int server)
    {
      socklen_t size = sizeof(sockaddr_in);
      fileDescriptor = ::accept(server, getSockaddr(), &size);
    }


    /**
     * Connect to port on local host.
     *
     * \param  port           port number
     */
    void connect(const int port)
    {
      connect(INADDR_ANY, port);
    }

    
    /**
     * Connect to port on specified host.
     *
     * \param  host_name      host name
     * \param  port           port number
     */
    void connect(const std::string& host_name, const int port)
    {
      connect(JSYSTEM::getIPnumber(host_name), port);
    }

    
    /**
     * Connect to port on specified host.
     *
     * \param  ip_number      IP number
     * \param  port           port number
     */
    void connect(const int ip_number, const int port)
    {
      setIPnumber(ip_number);
      setPort(port);

      if (::connect(getFileDescriptor(), getSockaddr(), sizeof(sockaddr_in)) < 0) {
        THROW(JSocketException, "Socket connection failed " << getIPaddress(ip_number) << ":" << port);
      }
    }


  protected:
    /**
     * Set socket option.
     *
     * \param  level          level
     * \param  option         option
     * \param  value          value
     */
    template<class T>
    void setOption(const int level, const int option, const T value)
    {
      socklen_t size = sizeof(T);

      if (setsockopt(getFileDescriptor(), level, option, &value, size) < 0) {
        THROW(JSocketException, "Set socket option failed.");
      }
    }


    /**
     * Get socket option.
     *
     * \param  level          level
     * \param  option         option
     * \return                value
     */
    template<class T>
    T getOption(const int level, const int option) const
    {
      T         value;
      socklen_t size  = sizeof(T);

      if (getsockopt(getFileDescriptor(), level, option, &value, &size) < 0) {
        THROW(JSocketException, "Get socket option failed.");
      }

      return value;
    }
  };
}

#endif