ccsocket.hpp

Go to the documentation of this file.

//
//  cpsocket: C++ Classes for TCP/IP and UDP Datagram INET Sockets.
//  (c) Eric Lecolinet 2016/17 - https://www.telecom-paristech.fr/~elc
//

#ifndef ccuty_ccsocket
#define ccuty_ccsocket

#include <string>
#include <sys/types.h>
#include <sys/socket.h>

namespace ccuty {
  
// ignore SIGPIPES when possible
#if defined(MSG_NOSIGNAL)
#  define _NO_SIGPIPE(flags) (flags | MSG_NOSIGNAL)
#else
#  define _NO_SIGPIPE(flags) (flags)
#endif
  
  class Socket {
  public:
    enum Errors {Failed = -1, InvalidSocket = -2, UnknownHost = -3};
    
    Socket(int type = SOCK_STREAM);
    
    Socket(int type, int sockfd);
    
    virtual ~Socket();
    
    virtual int bind(int port);
    
    virtual int bind(const std::string& host, int port);
    
    virtual int connect(const std::string& host, int port);
    
    virtual int close();
    
    bool isClosed() const {return _sockfd < 0;}
    
    int descriptor() {return _sockfd;}
    
    ssize_t send(const void* buf, size_t len, int flags = 0) {
      return ::send(_sockfd, buf, len, _NO_SIGPIPE(flags));
    }
    
    ssize_t receive(void* buf, size_t len, int flags = 0) {
      return ::recv(_sockfd, buf, len, flags);
    }
    
    ssize_t sendTo(const void* buf, size_t len, int flags,
                   const struct sockaddr* dest_addr, socklen_t addrlen) {
      return ::sendto(_sockfd, buf, len, _NO_SIGPIPE(flags), dest_addr, addrlen);
    }
    
    ssize_t receiveFrom(void* buf, size_t len, int flags,
                        struct sockaddr* src_addr, socklen_t* addrlen) {
      return ::recvfrom(_sockfd, buf, len, flags, src_addr, addrlen);
    }
    
    virtual void shutdownInput();
    
    virtual void shutdownOutput();
    
    int setReceiveBufferSize(int size);
    
    int setReuseAddress(bool);
    
    int setSendBufferSize(int size);
    
    int setSoLinger(bool, int linger);
    
    int setSoTimeout(int timeout);
    
    int setTcpNoDelay(bool);
    
    int getReceiveBufferSize() const;
    
    bool getReuseAddress() const;
    
    int getSendBufferSize() const;
    
    bool getSoLinger(int& linger) const;
    
    int getSoTimeout() const;
    
    bool getTcpNoDelay() const;
    
    virtual int setLocalAddress(struct sockaddr_in& addr, int port);
    
    virtual int setAddress(struct sockaddr_in& addr, const std::string& host, int port);
    
  private:
    friend class ServerSocket;
    int _sockfd;
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;
    Socket& operator=(Socket&&) = delete;
  };
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  class ServerSocket {
  public:
    ServerSocket();
    
    virtual ~ServerSocket();
    
    virtual Socket* accept();
    
    virtual int bind(int port, int backlog = 50);
    
    virtual int close();
    
    bool isClosed() const {return _sockfd < 0;}
    
    int descriptor() {return _sockfd;}
    
    int setReceiveBufferSize(int size);
    
    int setReuseAddress(bool);
    
    int setSoTimeout(int timeout);
    
    int setTcpNoDelay(bool);
    
  protected:
    virtual Socket* createSocket(int sockfd);
    
  private:
    int _sockfd;  // listening socket.
    ServerSocket(const ServerSocket&) = delete;
    ServerSocket& operator=(const ServerSocket&) = delete;
    ServerSocket& operator=(ServerSocket&&) = delete;
  };
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  class SocketBuffer {
  public:
    SocketBuffer(Socket* socket, size_t inputBufferSize = 8192, size_t ouputBufferSize = 8192);
    SocketBuffer(Socket& socket, size_t inputBufferSize = 8192, size_t ouputBufferSize = 8192);
    
    virtual ~SocketBuffer();
    
    virtual ssize_t readLine(std::string& message);
    
    virtual ssize_t writeLine(const std::string& message);
    
    /* Receives a given number of characters from a connected socket.
     * Reads *exactly* _len_ bytes from the socket, blocks otherwise.
     *
     * @return the number of bytes that were received or:
     * - 0: shutdownOutput() was called on the other side
     * - Socket::Failed (-1): a connection error occured
     * - Socket::InvalidSocket (-2): the socket is invalid.
     */
    virtual ssize_t read(char* buffer, size_t len);
    
    /* @brief Sends a given number of characters to a connected socket.
     * Writes _len_ bytes to the socket.
     *
     * @return the number of bytes that were sent or:
     * - 0: shutdownInput() was called on the other side
     * - Socket::Failed (-1): a connection error occured
     * - Socket::InvalidSocket (-2): the socket is invalid.
     */
    virtual ssize_t write(const char* str, size_t len);
    
    Socket* socket() {return _sock;}
    
    int readSeparator() const {return _inSep;}
    
    int writeSeparator() const {return _outSep;}
    
    virtual void setReadSeparator(int separ);
    
    virtual void setWriteSeparator(int separ);
    
  private:
    SocketBuffer(const SocketBuffer&) = delete;
    SocketBuffer& operator=(const SocketBuffer&) = delete;
    SocketBuffer& operator=(SocketBuffer&&) = delete;
    
  protected:
    virtual bool retrieveLine(std::string& str, ssize_t received);
    size_t _inSize, _outSize;
    int _inSep, _outSep;
    Socket* _sock;
    struct InputBuffer* _in;
  };
  
}

#endif