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
  };
 
  enum SocketPriority {
    NS3_PRIO_BESTEFFORT = 0,
    NS3_PRIO_FILLER = 1,
    NS3_PRIO_BULK = 2,
    NS3_PRIO_INTERACTIVE_BULK = 4,
    NS3_PRIO_INTERACTIVE = 6,
    NS3_PRIO_CONTROL = 7
  };
 
  enum Ipv6MulticastFilterMode
  {
    INCLUDE=1,
    EXCLUDE
  };
 
  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> > receivedData);
  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 int GetPeerName (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;
 
  void SetPriority (uint8_t priority);
 
  uint8_t GetPriority (void) const;
 
  static uint8_t IpTos2Priority (uint8_t ipTos);
 
  void SetIpTos (uint8_t ipTos);
 
  uint8_t GetIpTos (void) const;
 
  void SetIpRecvTos (bool ipv4RecvTos);
 
  bool IsIpRecvTos (void) const;
 
  void SetIpv6Tclass (int ipTclass);
 
  uint8_t GetIpv6Tclass (void) const;
 
  void SetIpv6RecvTclass (bool ipv6RecvTclass);
 
  bool IsIpv6RecvTclass (void) const;
 
  virtual void SetIpTtl (uint8_t ipTtl);
 
  virtual uint8_t GetIpTtl (void) const;
 
  void SetIpRecvTtl (bool ipv4RecvTtl);
 
  bool IsIpRecvTtl (void) const;
 
  virtual void SetIpv6HopLimit (uint8_t ipHopLimit);
 
  virtual uint8_t GetIpv6HopLimit (void) const;
 
  void SetIpv6RecvHopLimit (bool ipv6RecvHopLimit);
 
  bool IsIpv6RecvHopLimit (void) const;
 
  virtual void Ipv6JoinGroup (Ipv6Address address, Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses);
 
  virtual void Ipv6JoinGroup (Ipv6Address address);
 
  virtual void Ipv6LeaveGroup (void);
 
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);
 
  // inherited function, no doc necessary
  virtual void DoDispose (void);
 
  bool IsManualIpv6Tclass (void) const;
 
  bool IsManualIpTtl (void) const;
 
  bool IsManualIpv6HopLimit (void) const;
 
  Ptr<NetDevice> m_boundnetdevice; 
  bool m_recvPktInfo; 
  Ipv6Address m_ipv6MulticastGroupAddress; 
 
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;         
 
  uint8_t m_priority; 
 
  //IPv4 options
  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 SocketIpTtlTag : public Tag
{
public:
  SocketIpTtlTag ();
 
  void SetTtl (uint8_t ttl);
 
  uint8_t GetTtl (void) const;
 
  static TypeId GetTypeId (void);
 
  // inherited function, no need to doc.
  virtual TypeId GetInstanceTypeId (void) const;
 
  // inherited function, no need to doc.
  virtual uint32_t GetSerializedSize (void) const;
 
  // inherited function, no need to doc.
  virtual void Serialize (TagBuffer i) const;
 
  // inherited function, no need to doc.
  virtual void Deserialize (TagBuffer i);
 
  // inherited function, no need to doc.
  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);
 
  // inherited function, no need to doc.
  virtual TypeId GetInstanceTypeId (void) const;
 
  // inherited function, no need to doc.
  virtual uint32_t GetSerializedSize (void) const;
 
  // inherited function, no need to doc.
  virtual void Serialize (TagBuffer i) const;
 
  // inherited function, no need to doc.
  virtual void Deserialize (TagBuffer i);
 
  // inherited function, no need to doc.
  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);
 
  // inherited function, no need to doc.
  virtual TypeId GetInstanceTypeId (void) const;
 
  // inherited function, no need to doc.
  virtual uint32_t GetSerializedSize (void) const;
 
  // inherited function, no need to doc.
  virtual void Serialize (TagBuffer i) const;
 
  // inherited function, no need to doc.
  virtual void Deserialize (TagBuffer i);
 
  // inherited function, no need to doc.
  virtual void Print (std::ostream &os) const;
private:
  bool m_dontFragment; 
};
 
class SocketIpTosTag : public Tag
{
public:
  SocketIpTosTag ();
 
  void SetTos (uint8_t tos);
 
  uint8_t GetTos (void) const;
  
  static TypeId GetTypeId (void);
 
  // inherited function, no need to doc.
  virtual TypeId GetInstanceTypeId (void) const;
 
  // inherited function, no need to doc.
  virtual uint32_t GetSerializedSize (void) const;
 
  // inherited function, no need to doc.
  virtual void Serialize (TagBuffer i) const;
 
  // inherited function, no need to doc.
  virtual void Deserialize (TagBuffer i);
 
  // inherited function, no need to doc.
  virtual void Print (std::ostream &os) const;
private:
  uint8_t m_ipTos;  
};
 
class SocketPriorityTag : public Tag
{
public:
  SocketPriorityTag ();
 
  void SetPriority (uint8_t priority);
 
  uint8_t GetPriority (void) const;
 
  static TypeId GetTypeId (void);
 
  // inherited function, no need to doc.
  virtual TypeId GetInstanceTypeId (void) const;
 
  // inherited function, no need to doc.
  virtual uint32_t GetSerializedSize (void) const;
 
  // inherited function, no need to doc.
  virtual void Serialize (TagBuffer i) const;
 
  // inherited function, no need to doc.
  virtual void Deserialize (TagBuffer i);
 
  // inherited function, no need to doc.
  virtual void Print (std::ostream &os) const;
private:
  uint8_t m_priority;  
};
 
class SocketIpv6TclassTag : public Tag
{
public:
  SocketIpv6TclassTag ();
 
  void SetTclass (uint8_t tclass);
 
  uint8_t GetTclass (void) const;
  
  static TypeId GetTypeId (void);
 
  // inherited function, no need to doc.
  virtual TypeId GetInstanceTypeId (void) const;
 
  // inherited function, no need to doc.
  virtual uint32_t GetSerializedSize (void) const;
 
  // inherited function, no need to doc.
  virtual void Serialize (TagBuffer i) const;
 
  // inherited function, no need to doc.
  virtual void Deserialize (TagBuffer i);
 
  // inherited function, no need to doc.
  virtual void Print (std::ostream &os) const;
private:
  uint8_t m_ipv6Tclass; 
};
 
} // namespace ns3
 
#endif /* NS3_SOCKET_H */