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;

  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;
 
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 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);

  // 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:
  Address m_address; 
};

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 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 */