tdsocket.h

Go to the documentation of this file.

/*
 *  $Id: tdsocket.h 1285 2011-12-18 13:25:14Z dreibh $
 *
 * SocketAPI implementation for the sctplib.
 * Copyright (C) 2005-2012 by Thomas Dreibholz
 *
 * Realized in co-operation between
 * - Siemens AG
 * - University of Essen, Institute of Computer Networking Technology
 * - University of Applied Sciences, Muenster
 *
 * Acknowledgement
 * This work was partially funded by the Bundesministerium fuer Bildung und
 * Forschung (BMBF) of the Federal Republic of Germany (Foerderkennzeichen 01AK045).
 * The authors alone are responsible for the contents.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 * Contact: discussion@sctp.de
 *          dreibh@iem.uni-due.de
 *          tuexen@fh-muenster.de
 *
 * Purpose: Socket Implementation
 *
 */


#ifndef TDSOCKET_H
#define TDSOCKET_H


#include "tdsystem.h"
#include "internetaddress.h"
#include "internetflow.h"
#include "ext_socket.h"


#include <fcntl.h>



const cardinal UDPHeaderSize = 8;

const cardinal IPv4HeaderSize = 20;

const cardinal IPv6HeaderSize = 40;


class Socket
{
   // ====== Definitions ====================================================
   public:
   enum SocketFamily {
      UndefinedSocketFamily = -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,
      SCTP                    = IPPROTO_SCTP
   };
   enum GetSocketAddressFlags {
      GLAF_HideLoopback       = (1 << 0),
      GLAF_HideLinkLocal      = (1 << 1),
      GLAF_HideSiteLocal      = (1 << 2),
      GLAF_HideLocal          = GLAF_HideLoopback|GLAF_HideLinkLocal|GLAF_HideSiteLocal,
      GLAF_HideAnycast        = (1 << 3),
      GLAF_HideMulticast      = (1 << 4),
      GLAF_HideBroadcast      = (1 << 5),
      GLAF_HideReserved       = (1 << 6),
      GLAF_Default            = GLAF_HideLoopback|GLAF_HideLinkLocal|Socket::GLAF_HideSiteLocal|GLAF_HideBroadcast|GLAF_HideMulticast|GLAF_HideAnycast
   };


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

   Socket(const integer family,
          const integer socketType,
          const integer socketProtocol = Default);

   ~Socket();


   // ====== Create/close socket ============================================
   bool create(const integer socketFamily   = IP,
               const integer socketType     = TCP,
               const integer socketProtocol = Default);

   void close();

   void shutdown(const cardinal shutdownLevel);


   // ====== Socket properties ==============================================
   inline integer getFamily() const;

   inline integer getType() const;

   inline integer getProtocol() const;


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

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

   bool bindx(const SocketAddress** addressArray = NULL,
              const cardinal        addresses    = 0,
              const integer         flags        = 0);

   bool listen(const cardinal backlog = 5);

   Socket* accept(SocketAddress** address = NULL);

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


   bool connectx(const SocketAddress** addressArray,
                 const size_t          addresses);

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


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

   cardinal getSoLinger();

   bool getSoReuseAddress();

   bool getSoBroadcast();

   bool getTCPNoDelay();

   bool getBlockingMode();


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

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

   bool setSoReuseAddress(const bool on);

   bool setSoBroadcast(const bool on);

   bool setTCPNoDelay(const bool on);

   bool 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 ==================================================
   ssize_t send(const void*   buffer,
                const size_t  length,
                const integer flags        = 0,
                const card8   trafficClass = 0x00);

   ssize_t sendTo(const void*          buffer,
                  const size_t         length,
                  const integer        flags,
                  const SocketAddress& receiver,
                  const card8          trafficClass = 0x00);

   ssize_t sendMsg(const struct msghdr* msg,
                   const integer        flags,
                   const card8          trafficClass = 0x00);

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

   inline ssize_t receive(void*        buffer,
                          const size_t length,
                          integer&     flags);

   ssize_t receiveFrom(void*          buffer,
                       const size_t   length,
                       SocketAddress& sender,
                       integer&       flags);

   ssize_t receiveMsg(struct msghdr* msg,
                      const integer  flags,
                      const bool     internalCall = false);

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

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

   inline integer fcntl(const integer cmd, struct flock* lock);

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


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

   bool getPeerAddress(SocketAddress& address) const;


   // ====== Multicast functions ============================================
   inline bool addMulticastMembership(const SocketAddress& address,
                                      const char* interface = NULL);

   inline bool dropMulticastMembership(const SocketAddress& address,
                                       const char* interface = NULL);

   bool getMulticastLoop();

   bool setMulticastLoop(const bool on);

   card8 getMulticastTTL();

   bool setMulticastTTL(const card8 ttl);


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

   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 sockets ===========================================
   static bool bindSocketPair(Socket&              socket1,
                              Socket&              socket2,
                              const SocketAddress& address = InternetAddress());

   static bool bindxSocketPair(Socket&               socket1,
                               Socket&               socket2,
                               const SocketAddress** addressArray = NULL,
                               const cardinal        addresses    = 0,
                               const integer         flags        = 0);


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


   // ====== Obtaining Local addresses ======================================
   static bool getLocalAddressList(SocketAddress**& addressList,
                                   cardinal&        numberOfNets,
                                   const cardinal   flags = GLAF_Default);


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

   static const cardinal MaxAutoSelectPort = 61000;


   // ====== Private data ===================================================
   private:
   friend class TrafficShaper;
   void init();
   bool setTypeOfService(const card8 trafficClass);
   ssize_t recvFrom(int              fd,
                    void*            buf,
                    const size_t     len,
                    integer&         flags,
                    struct sockaddr* addr,
                    socklen_t*       addrlen);
   bool multicastMembership(const SocketAddress& address,
                            const char*          interface,
                            const bool           add);
   void packSocketAddressArray(const sockaddr_storage* addrArray,
                               const size_t            addrs,
                               sockaddr*               packedArray);


   int       SocketDescriptor;
   integer   Family;
   integer   Type;
   integer   Protocol;
   card32    SendFlow;
   card32    ReceivedFlow;
   integer   LastError;
   cardinal  Backlog;
   sockaddr* Destination;
};


#include "tdsocket.icc"


#endif