socket.h

/*
 *      Copyright (C) 2014-2015 Jean-Luc Barriere
 *
 *  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 3, 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; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301 USA
 *  http://www.gnu.org/copyleft/gpl.html
 *
 */
 
#ifndef SOCKET_H
#define SOCKET_H
 
#include "local_config.h"
#include "os/os.h"
 
#include <cstddef>  // for size_t
#include <string>
 
#define SOCKET_HOSTNAME_MAXSIZE       256
#define SOCKET_RCVBUF_MINSIZE         16384
#define SOCKET_TIMEOUT_SEC            10
#define SOCKET_TIMEOUT_USEC           0
#define SOCKET_READ_ATTEMPT           3
#define SOCKET_BUFFER_SIZE            1472
#define SOCKET_LISTEN_QUEUE_SIZE      50
 
namespace NSROOT
{
 
  typedef enum {
    SOCKET_AF_INET4,
    SOCKET_AF_INET6,
  } SOCKET_AF_t;
 
  struct SocketAddress;
 
  class NetSocket
  {
  public:
    NetSocket()
    {
      m_timeout.tv_sec = SOCKET_TIMEOUT_SEC;
      m_timeout.tv_usec = SOCKET_TIMEOUT_USEC;
    }
    virtual ~NetSocket() { }
    virtual bool SendData(const char* buf, size_t size) = 0;
    virtual size_t ReceiveData(void* buf, size_t n) = 0;
    void SetTimeout(timeval timeout) { m_timeout = timeout; }
 
  protected:
    struct timeval m_timeout;
  };
 
  class TcpSocket : public NetSocket
  {
    friend class TcpServerSocket;
  public:
    TcpSocket();
    virtual ~TcpSocket();

    int GetErrNo() const { return m_errno; }

    void SetReadAttempt(int n) { m_attempt = n; }

    virtual bool Connect(const char* server, unsigned port, int rcvbuf);

    virtual bool SendData(const char* buf, size_t size);

    virtual size_t ReceiveData(void* buf, size_t n);

    virtual size_t BlockingRead(void* buf, size_t n);

    virtual void Disconnect();

    virtual bool IsValid() const;

    int Listen(timeval *timeout);

    net_socket_t GetHandle() const { return m_socket; }

    std::string GetRemoteAddrInfo();

    std::string GetHostAddrInfo();

    static const char* GetMyHostName();
 
  protected:
    net_socket_t m_socket;
    int m_rcvbuf;
    int m_errno;
    int m_attempt;
 
  private:
    char* m_buffer;
    char* m_bufptr;
    size_t m_buflen;
    size_t m_rcvlen;
 
    // prevent copy
    TcpSocket(const TcpSocket&);
    TcpSocket& operator=(const TcpSocket&);
  };
 
  class TcpServerSocket
  {
  public:
    TcpServerSocket();
    virtual ~TcpServerSocket();

    int GetErrNo() const { return m_errno; }

    bool Create(SOCKET_AF_t af);

    bool IsValid() const;

    bool Bind(unsigned port);

    bool ListenConnection(int queueSize = SOCKET_LISTEN_QUEUE_SIZE);
 
    enum AcceptStatus
    {
      ACCEPT_ERROR      = -1,
      ACCEPT_TIMEOUT    = 0,
      ACCEPT_SUCCESS    = 1,
      ACCEPT_FAILURE    = 2,
    };
    AcceptStatus AcceptConnection(TcpSocket& socket, int timeout);

    std::string GetRemoteAddrInfo();

    void Close();

    net_socket_t GetHandle() const { return m_socket; }
 
  private:
    SocketAddress* m_addr;
    net_socket_t m_socket;
    int m_errno;
    unsigned m_requestQueueSize;
 
    // prevent copy
    TcpServerSocket(const TcpServerSocket&);
    TcpServerSocket& operator=(const TcpServerSocket&);
  };
 
  class UdpSocket : public NetSocket
  {
  public:
    UdpSocket();
    UdpSocket(size_t bufferSize);
    virtual ~UdpSocket();

    int GetErrNo() const { return m_errno; }

    bool SendData(const char* buf, size_t size);

    size_t ReceiveData(void* buf, size_t n);

    bool IsValid() const;

    bool Open(SOCKET_AF_t af, const char* target, unsigned port);

    bool Open(SOCKET_AF_t af, bool broadcast = false);

    bool SetAddress(const char* target, unsigned port);

    bool SetMulticastTTL(int multicastTTL);

    std::string GetRemoteAddrInfo() const;

    net_socket_t GetHandle() const { return m_socket; }
 
  private:
    SocketAddress* m_addr;
    SocketAddress* m_from;
    net_socket_t m_socket;
    int m_errno;
    char* m_buffer;
    char* m_bufptr;
    size_t m_buflen;
    size_t m_rcvlen;
 
    // prevent copy
    UdpSocket(const UdpSocket&);
    UdpSocket& operator=(const UdpSocket&);
  };
 
  class UdpServerSocket : public NetSocket
  {
  public:
    UdpServerSocket();
    UdpServerSocket(size_t bufferSize);
    ~UdpServerSocket();

    int GetErrNo() const { return m_errno; }

    bool Create(SOCKET_AF_t af);

    bool IsValid() const;

    bool Bind(unsigned port, bool reuse = false);

    bool Bind(const char* addr, unsigned port, bool reuse = false);

    bool SetMulticastTTL(int multicastTTL);

    bool SetMulticastMembership(const char *group, bool join);

    size_t AwaitIncoming();

    std::string GetRemoteAddrInfo() const;

    bool SendData(const char*, size_t) { return false; }

    size_t ReceiveData(void* buf, size_t n)
    {
      size_t r = 0;
      if (IsValid())
      {
        if ((r = ReadData(buf, n)) > 0)
          return r;
        if (AwaitIncoming() > 0)
          return ReadData(buf, n);
      }
      return r;
    }

    size_t ReadData(void* buf, size_t n);

    net_socket_t GetHandle() const { return m_socket; }
 
  private:
    SocketAddress* m_addr;
    SocketAddress* m_from;
    net_socket_t m_socket;
    int m_errno;
    char* m_buffer;
    char* m_bufptr;
    size_t m_buflen;
    size_t m_rcvlen;
 
    // prevent copy
    UdpServerSocket(const UdpServerSocket&);
    UdpServerSocket& operator=(const UdpServerSocket&);
  };
 
}
 
#endif  /* SOCKET_H */