socket.h

Go to the documentation of this file.

// ##########################################################################
// ####                                                                  ####
// ####                      RTP Audio Server Project                    ####
// ####                    ============================                  ####
// ####                                                                  ####
// #### Socket                                                           ####
// ####                                                                  ####
// #### Version 1.00  --  February 16, 2001                              ####
// ####                                                                  ####
// #### Copyright (C) 1999  Thomas Dreibholz                             ####
// ####               2000  Universität Bonn, Abt. IV                    ####
// ####               2001  EMail: dreibh@iem.uni-due.de                 ####
// ####                     WWW:   https://www.uni-due.de/~be0001        ####
// ####                                                                  ####
// ##########################################################################


#ifndef SOCKETCLASS_H
#define SOCKETCLASS_H


#include "system.h"
#include "internetaddress.h"
#include "internetflow.h"


namespace Coral {


const cardinal UDPHeaderSize = 8;

const cardinal IPv4HeaderSize = 20;

const cardinal IPv6HeaderSize = 40;


class Socket
{
   // ====== Definitions ====================================================
   public:
   enum SocketCommunicationDomain {
      UndefinedSocketCommunicationDomain = -1,
      IP                                 = 255,
      IPv4                               = AF_INET,  // Do not use IPv4/IPv6!
      IPv6                               = AF_INET6, // Use IP instead!
      Unix                               = AF_UNIX
   }; 
   enum SocketType {
      UndefinedSocketType = -1,
      UDP                 = SOCK_DGRAM,
      Datagram            = SOCK_DGRAM,
      TCP                 = SOCK_STREAM,
      Stream              = SOCK_STREAM,
      Raw                 = SOCK_RAW,
      RDM                 = SOCK_RDM,
      SeqPacket           = SOCK_SEQPACKET
   };
   enum SocketProtocol {
      UndefinedSocketProtocol = -1,
      Default                 = 0,
      ICMPv4                  = IPPROTO_ICMP,
      ICMPv6                  = IPPROTO_ICMPV6
   };

   // ====== Constructor/Destructor =========================================
   Socket();

   Socket(const SocketCommunicationDomain communicationDomain,
          const SocketType                socketType,
          const SocketProtocol            socketProtocol = Default);

   virtual ~Socket();


   // ====== Create/close socket ============================================
   bool create(const SocketCommunicationDomain communicationDomain = IP,
               const SocketType                socketType          = TCP,          
               const SocketProtocol            socketProtocol      = Default);

   void close();

   void shutdown(const cardinal shutdownLevel);


   // ====== Statistics functions ===========================================
   inline card64 getBytesSent() const;

   inline card64 getBytesReceived() const;
   
   inline void resetBytesSent();

   inline void resetBytesReceived();

   
   // ====== Socket control functions =======================================
   inline bool ready() const;

   bool bind(const SocketAddress& address = InternetAddress());

   bool listen(const cardinal backlog = 5);

   Socket* accept();

   bool connect(const SocketAddress& address, const card8 trafficClass = 0);


   // ====== Error code =====================================================
   inline integer getLastError();


   // ====== Socket options =================================================
   inline integer getSocketOption(const cardinal level,
                                  const cardinal optionNumber,
                                  void*          optionValue,
                                  socklen_t*     optionLength) const;

   cardinal getSoLinger() const;

   bool getSoReuseAddress() const;

   bool getSoBroadcast() const;

   bool getTCPNoDelay() const;

   bool getBlockingMode();


   inline integer setSocketOption(const cardinal  level,
                                  const cardinal  optionNumber,
                                  const void*     optionValue,
                                  const socklen_t optionLength);

   void setSoLinger(const bool on, const cardinal linger);

   void setSoReuseAddress(const bool on);

   void setSoBroadcast(const bool on);

   void setTCPNoDelay(const bool on);

   void setBlockingMode(const bool on);


   // ====== Get flow label/traffic class ===================================
   inline card32 getSendFlowLabel() const;

   inline card8 getSendTrafficClass() const;

   inline card32 getReceivedFlowLabel() const;

   inline card8 getReceivedTrafficClass() const;

   
   // ====== I/O functions ==================================================
   virtual ssize_t sendTo(const void*          buffer,
                          const size_t         length,
                          const cardinal       flags,
                          const SocketAddress& receiver,
                          const card8          trafficClass = 0);

   virtual ssize_t send(const void*    buffer,
                        const size_t   length,
                        const cardinal flags        = 0,
                        const card8    trafficClass = 0);

   virtual ssize_t receiveFrom(void*          buffer,
                               const size_t   length,
                               SocketAddress& sender,
                               const cardinal flags = 0);

   virtual ssize_t receive(void*          buffer,
                           const size_t   length,
                           const cardinal flags = 0);

   virtual ssize_t read(void*        buffer,
                        const size_t length);

   virtual ssize_t write(const void*  buffer,
                         const size_t length);

   inline integer fcntl(const integer cmd, const long arg = 0);


   inline integer ioctl(const integer request, const void* argp);

                                                          
   // ====== Get address ====================================================
   bool getSocketAddress(SocketAddress& address) const;

   bool getPeerAddress(SocketAddress& address) const;


   // ====== IPv6 flow functions ============================================
   InternetFlow allocFlow(const InternetAddress& address,
                          const card32           flowLabel  = 0,
                          const card8            shareLevel = IPV6_FL_S_PROCESS);

   void freeFlow(InternetFlow& flow);

   bool renewFlow(InternetFlow&  flow,
                  const cardinal expires,
                  const cardinal linger = 6);

   bool renewFlow(const cardinal expires,
                  const cardinal linger = 6);


   // ====== Bind pair of internet sockets ==================================
   static bool bindInternetSocketPair(Socket&                senderSocket,
                                      Socket&                receiverSocket,
                                      const InternetAddress& receiver = InternetAddress());


   // ====== Traffic shaper methods =========================================
   virtual void setTrafficConstraint(const card8  trafficClass,
                                     const card64 bandwidth,
                                     const double bufferDelay);

   virtual void flush();


   // ====== Get system's socket descriptor =================================
   inline int getSystemSocketDescriptor() const;


   // ====== Constants ======================================================
   static const cardinal MinAutoSelectPort = 16384;

   static const cardinal MaxAutoSelectPort = 65535;


   // ====== Private data ===================================================
   protected:
   friend class TrafficShaper;


   void init();
   bool setTOS(const card8 trafficClass);
   ssize_t recvFrom(int              fd,
                    void*            buf,
                    const size_t     len,
                    const integer    flags,
                    struct sockaddr* addr,
                    size_t*          addrlen);


   card64                    BytesSent;
   card64                    BytesReceived;
   card32                    SendFlow;
   card32                    ReceivedFlow;
   cardinal                  Backlog;
   cardinal                  LastError;
   int                       SocketDescriptor;
   sockaddr*                 Destination;
   SocketCommunicationDomain CommunicationDomain;
   SocketType                Type;
   SocketProtocol            Protocol;
};


}


#include "socket.icc"


#endif