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>

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

};

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

} // namespace ns3

#endif /* NS3_SOCKET_H */