socket.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2006 Georgia Tech Research Corporation
 *               2007 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Authors: George F. Riley<riley@ece.gatech.edu>
 *          Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */

#ifndef NS3_SOCKET_H
#define NS3_SOCKET_H

#include "ns3/callback.h"
#include "ns3/ptr.h"
#include "ns3/tag.h"
#include "ns3/object.h"
#include "ns3/net-device.h"
#include "address.h"
#include <stdint.h>
#include "ns3/inet-socket-address.h"
#include "ns3/inet6-socket-address.h"

namespace ns3 {


class Node;
class Packet;

class Socket : public Object
{
public:
  static TypeId GetTypeId (void);

  Socket (void);
  virtual ~Socket (void);

  enum SocketErrno {
    ERROR_NOTERROR,
    ERROR_ISCONN,
    ERROR_NOTCONN,
    ERROR_MSGSIZE,
    ERROR_AGAIN,
    ERROR_SHUTDOWN,
    ERROR_OPNOTSUPP,
    ERROR_AFNOSUPPORT,
    ERROR_INVAL,
    ERROR_BADF,
    ERROR_NOROUTETOHOST,
    ERROR_NODEV,
    ERROR_ADDRNOTAVAIL,
    ERROR_ADDRINUSE,
    SOCKET_ERRNO_LAST
  };

  enum SocketType {
    NS3_SOCK_STREAM,
    NS3_SOCK_SEQPACKET,
    NS3_SOCK_DGRAM,
    NS3_SOCK_RAW
  };

  static Ptr<Socket> CreateSocket (Ptr<Node> node, TypeId tid);
  virtual enum Socket::SocketErrno GetErrno (void) const = 0;
  virtual enum Socket::SocketType GetSocketType (void) const = 0;
  virtual Ptr<Node> GetNode (void) const = 0;
  void SetConnectCallback (Callback<void, Ptr<Socket> > connectionSucceeded,
                           Callback<void,  Ptr<Socket> > connectionFailed);
  void SetCloseCallbacks (Callback<void, Ptr<Socket> > normalClose,
                          Callback<void, Ptr<Socket> > errorClose);
  void SetAcceptCallback (Callback<bool, Ptr<Socket>, 
                                   const Address &> connectionRequest,
                          Callback<void, Ptr<Socket>, 
                                   const Address&> newConnectionCreated);
  void SetDataSentCallback (Callback<void, Ptr<Socket>, 
                                     uint32_t> dataSent);
  void SetSendCallback (Callback<void, Ptr<Socket>, uint32_t> sendCb);
  void SetRecvCallback (Callback<void, Ptr<Socket> >);
  virtual int Bind (const Address &address) = 0;

  virtual int Bind () = 0;

  virtual int Bind6 () = 0;

  virtual int Close (void) = 0;

  virtual int ShutdownSend (void) = 0;

  virtual int ShutdownRecv (void) = 0;

  virtual int Connect (const Address &address) = 0;

  virtual int Listen (void) = 0;

  virtual uint32_t GetTxAvailable (void) const = 0;
 
  virtual int Send (Ptr<Packet> p, uint32_t flags) = 0;

  virtual int SendTo (Ptr<Packet> p, uint32_t flags, 
                      const Address &toAddress) = 0;

  virtual uint32_t GetRxAvailable (void) const = 0;

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags) = 0;

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,
                                Address &fromAddress) = 0;

  //   The remainder of these public methods are overloaded methods  //
  //   or variants of Send() and Recv(), and they are non-virtual    //
 
  int Send (Ptr<Packet> p);

  int Send (const uint8_t* buf, uint32_t size, uint32_t flags);


  int SendTo (const uint8_t* buf, uint32_t size, uint32_t flags, 
              const Address &address); 

  Ptr<Packet> Recv (void);

  int Recv (uint8_t* buf, uint32_t size, uint32_t flags);

  Ptr<Packet> RecvFrom (Address &fromAddress);

  int RecvFrom (uint8_t* buf, uint32_t size, uint32_t flags,
                Address &fromAddress);
  virtual int GetSockName (Address &address) const = 0; 

  virtual void BindToNetDevice (Ptr<NetDevice> netdevice);

  Ptr<NetDevice> GetBoundNetDevice (); 


  virtual bool SetAllowBroadcast (bool allowBroadcast) = 0;

  virtual bool GetAllowBroadcast () const = 0;

  void SetRecvPktInfo (bool flag);

  bool IsRecvPktInfo () const;

  /*
   * \brief Manually set IP Type of Service field
   * 
   * This method corresponds to using setsockopt () IP_TOS of
   * real network or BSD sockets. This option is for IPv4 only.
   * Setting the IP TOS should also change the socket queueing
   * priority as stated in the man page. However, socket priority
   * is not yet supported.
   *
   * \param ipTos The desired TOS value for IP headers
   */
  void SetIpTos (uint8_t ipTos);

  /*
   * \brief Query the value of IP Type of Service of this socket
   *
   * This method corresponds to using getsockopt () IP_TOS of real network
   * or BSD sockets.
   *
   * \return The raw IP TOS value
   */
  uint8_t GetIpTos (void) const;

  void SetIpRecvTos (bool ipv4RecvTos);

  bool IsIpRecvTos (void) const;

  /*
   * \brief Manually set IPv6 Traffic Class field
   * 
   * This method corresponds to using setsockopt () IPV6_TCLASS of
   * real network or BSD sockets. This option is for IPv6 only.
   * Setting the IPV6_TCLASSS to -1 clears the option and let the socket
   * uses the default value.
   *
   * \param ipTclass The desired TCLASS value for IPv6 headers
   */
  void SetIpv6Tclass (int ipTclass);

  /*
   * \brief Query the value of IPv6 Traffic Class field of this socket
   *
   * This method corresponds to using getsockopt () IPV6_TCLASS of real network
   * or BSD sockets.
   *
   * \return The raw IPV6_TCLASS value
   */
  uint8_t GetIpv6Tclass (void) const;

  void SetIpv6RecvTclass (bool ipv6RecvTclass);

  bool IsIpv6RecvTclass (void) const;

  /*
   * \brief Manually set IP Time to Live field
   * 
   * This method corresponds to using setsockopt () IP_TTL of
   * real network or BSD sockets.
   *
   * \param ipTtl The desired TTL value for IP headers
   */
  virtual void SetIpTtl (uint8_t ipTtl);

  /*
   * \brief Query the value of IP Time to Live field of this socket
   *
   * This method corresponds to using getsockopt () IP_TTL of real network
   * or BSD sockets.
   *
   * \return The raw IP TTL value
   */
  virtual uint8_t GetIpTtl (void) const;

  void SetIpRecvTtl (bool ipv4RecvTtl);

  bool IsIpRecvTtl (void) const;

  /*
   * \brief Manually set IPv6 Hop Limit
   * 
   * This method corresponds to using setsockopt () IPV6_HOPLIMIT of
   * real network or BSD sockets.
   *
   * \param ipHopLimit The desired Hop Limit value for IPv6 headers
   */
  virtual void SetIpv6HopLimit (uint8_t ipHopLimit);

  /*
   * \brief Query the value of IP Hop Limit field of this socket
   *
   * This method corresponds to using getsockopt () IPV6_HOPLIMIT of real network
   * or BSD sockets.
   *
   * \return The raw IPv6 Hop Limit value
   */
  virtual uint8_t GetIpv6HopLimit (void) const;

  void SetIpv6RecvHopLimit (bool ipv6RecvHopLimit);

  bool IsIpv6RecvHopLimit (void) const;
 
protected:
  void NotifyConnectionSucceeded (void);
  void NotifyConnectionFailed (void);
  void NotifyNormalClose (void);
  void NotifyErrorClose (void);
  bool NotifyConnectionRequest (const Address &from);
  void NotifyNewConnectionCreated (Ptr<Socket> socket, const Address &from);
  void NotifyDataSent (uint32_t size);
  void NotifySend (uint32_t spaceAvailable);
  void NotifyDataRecv (void);
  virtual void DoDispose (void);

  bool IsManualIpTos (void) const;
  bool IsManualIpv6Tclass (void) const;
  bool IsManualIpTtl (void) const;
  bool IsManualIpv6HopLimit (void) const;

  Ptr<NetDevice> m_boundnetdevice;
  bool m_recvPktInfo;

private:
  Callback<void, Ptr<Socket> >                   m_connectionSucceeded;
  Callback<void, Ptr<Socket> >                   m_connectionFailed;
  Callback<void, Ptr<Socket> >                   m_normalClose;
  Callback<void, Ptr<Socket> >                   m_errorClose;
  Callback<bool, Ptr<Socket>, const Address &>   m_connectionRequest;
  Callback<void, Ptr<Socket>, const Address&>    m_newConnectionCreated;
  Callback<void, Ptr<Socket>, uint32_t>          m_dataSent;
  Callback<void, Ptr<Socket>, uint32_t >         m_sendCb;
  Callback<void, Ptr<Socket> >                   m_receivedData;

  //IPv4 options
  bool m_manualIpTos;
  bool m_manualIpTtl;
  bool m_ipRecvTos;
  bool m_ipRecvTtl;

  uint8_t m_ipTos;
  uint8_t m_ipTtl;

  //IPv6 options
  bool m_manualIpv6Tclass;
  bool m_manualIpv6HopLimit;
  bool m_ipv6RecvTclass;
  bool m_ipv6RecvHopLimit;

  uint8_t m_ipv6Tclass;
  uint8_t m_ipv6HopLimit;
};

class SocketAddressTag : public Tag
{
public:
  SocketAddressTag ();
  void SetAddress (Address addr);
  Address GetAddress (void) const;

  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
  virtual uint32_t GetSerializedSize (void) const;
  virtual void Serialize (TagBuffer i) const;
  virtual void Deserialize (TagBuffer i);
  virtual void Print (std::ostream &os) const;

private:
  Address m_address;
};

class SocketIpTtlTag : public Tag
{
public:
  SocketIpTtlTag ();
  void SetTtl (uint8_t ttl);
  uint8_t GetTtl (void) const;

  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
  virtual uint32_t GetSerializedSize (void) const;
  virtual void Serialize (TagBuffer i) const;
  virtual void Deserialize (TagBuffer i);
  virtual void Print (std::ostream &os) const;

private:
  uint8_t m_ttl;
};

class SocketIpv6HopLimitTag : public Tag
{
public:
  SocketIpv6HopLimitTag ();
  void SetHopLimit (uint8_t hopLimit);
  uint8_t GetHopLimit (void) const;

  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
  virtual uint32_t GetSerializedSize (void) const;
  virtual void Serialize (TagBuffer i) const;
  virtual void Deserialize (TagBuffer i);
  virtual void Print (std::ostream &os) const;

private:
  uint8_t m_hopLimit;
};

class SocketSetDontFragmentTag : public Tag
{
public:
  SocketSetDontFragmentTag ();
  void Enable (void);
  void Disable (void);
  bool IsEnabled (void) const;

  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
  virtual uint32_t GetSerializedSize (void) const;
  virtual void Serialize (TagBuffer i) const;
  virtual void Deserialize (TagBuffer i);
  virtual void Print (std::ostream &os) const;
private:
  bool m_dontFragment;
};

/*
 * \brief indicated whether the socket has IP_TOS set.
 * This tag is for IPv4 socket.
 */
class SocketIpTosTag : public Tag
{
public:
  SocketIpTosTag ();
  void SetTos (uint8_t tos);
  uint8_t GetTos (void) const;
  
  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
  virtual uint32_t GetSerializedSize (void) const;
  virtual void Serialize (TagBuffer i) const;
  virtual void Deserialize (TagBuffer i);
  virtual void Print (std::ostream &os) const;
private:
  uint8_t m_ipTos;
};

/*
 * \brief indicated whether the socket has IPV6_TCLASS set.
 * This tag is for IPv6 socket.
 */
class SocketIpv6TclassTag : public Tag
{
public:
  SocketIpv6TclassTag ();
  void SetTclass (uint8_t tclass);
  uint8_t GetTclass (void) const;
  
  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
  virtual uint32_t GetSerializedSize (void) const;
  virtual void Serialize (TagBuffer i) const;
  virtual void Deserialize (TagBuffer i);
  virtual void Print (std::ostream &os) const;
private:
  uint8_t m_ipv6Tclass;
};

} // namespace ns3

#endif /* NS3_SOCKET_H */