Attachment #3060 for bug #2882

View | Details | Raw Unified | Return to bug 2882
Collapse All | Expand All




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#include "raw-application-helper.h"
#include "ns3/names.h"
#include "ns3/packet-socket-factory.h"
#include "ns3/packet-socket-helper.h"
#include "ns3/net-device.h"
#include "ns3/address.h"


namespace ns3 {

RawApplicationHelper::RawApplicationHelper ()
{
  m_factory.SetTypeId ("ns3::RawApplication");
}

void 
RawApplicationHelper::SetAttribute (std::string name, const AttributeValue &value)
{
  m_factory.Set (name, value);
}

ApplicationContainer
RawApplicationHelper::Install (Ptr<Node> node) const
{
  return ApplicationContainer (DoInstall (node));
}

ApplicationContainer
RawApplicationHelper::Install (std::string nodeName) const
{
  Ptr<Node> node = Names::Find<Node> (nodeName);
  return ApplicationContainer (DoInstall (node));
}

ApplicationContainer
RawApplicationHelper::Install (NodeContainer c) const
{
  ApplicationContainer apps;
  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
    {
      apps.Add (DoInstall (*i));
    }

  return apps;
}

Ptr<Application>
RawApplicationHelper::DoInstall (Ptr<Node> node) const
{
  if(node->GetObject<PacketSocketFactory> () == NULL)
    {
      PacketSocketHelper packetSocketHelper;
      packetSocketHelper.Install (node);
    }

  Ptr<Application> app = m_factory.Create<Application> ();
  node->AddApplication (app);

  return app;
}

} // namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#ifndef RAW_APPLICATION_HELPER_H
#define RAW_APPLICATION_HELPER_H


#include "ns3/object-factory.h"
#include "ns3/attribute.h"
#include "ns3/node-container.h"
#include "ns3/application-container.h"

namespace ns3 {

/**
 * \ingroup applications
 * \brief A helper to make it easier to instantiate an ns3::RawApplication 
 * on a set of nodes.
 */
class RawApplicationHelper
{
public:
  /**
   * Create a RawApplicationHelper to make it easier to work with RawApplication
   */
  RawApplicationHelper ();

  /**
   * Helper function used to set the underlying application attributes.
   */
  void SetAttribute (std::string name, const AttributeValue &value);

  /**
   * Install an ns3::RawApplication on each node of the input container
   * configured with all the attributes set with SetAttribute.
   *
   * \param c NodeContainer of the set of nodes on which a RawApplication 
   * will be installed.
   * \returns Container of Ptr to the applications installed.
   */
  ApplicationContainer Install (NodeContainer c) const;

  /**
   * Install an ns3::RawApplication on the node configured with all the 
   * attributes set with SetAttribute.
   *
   * \param node The node on which a RawApplication will be installed.
   * \returns Container of Ptr to the applications installed.
   */
  ApplicationContainer Install (Ptr<Node> node) const;

  /**
   * Install an ns3::RawApplication on the node configured with all the 
   * attributes set with SetAttribute.
   *
   * \param nodeName The node on which a RawApplication will be installed.
   * \returns Container of Ptr to the applications installed.
   */
  ApplicationContainer Install (std::string nodeName) const;

private:
  /**
   * Install an ns3::RawApplication on the node configured with all the 
   * attributes set with SetAttribute.
   *
   * \param node The node on which a RawApplication will be installed.
   * \returns Ptr to the application installed.
   */
  Ptr<Application> DoInstall (Ptr<Node> node) const;

  ObjectFactory m_factory; //!< Object factory.
};

} // namespace ns3

#endif /* RAW_APPLICATION_HELPER_H */





/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#include "udp-application-helper.h"
#include "ns3/names.h"
#include "ns3/packet-socket-factory.h"
#include "ns3/packet-socket-helper.h"
#include "ns3/net-device.h"
#include "ns3/address.h"
#include "ns3/udp-application.h"
#include "ns3/internet-stack-helper.h"


namespace ns3 {

UdpApplicationHelper::UdpApplicationHelper ()
  : m_port (0)
{
  m_factory.SetTypeId ("ns3::UdpApplication");
}

void 
UdpApplicationHelper::SetAttribute (std::string name, const AttributeValue &value)
{
  m_factory.Set (name, value);
}

ApplicationContainer
UdpApplicationHelper::Install (Ptr<Node> node) const
{
  return ApplicationContainer (DoInstall (node));
}

ApplicationContainer
UdpApplicationHelper::Install (std::string nodeName) const
{
  Ptr<Node> node = Names::Find<Node> (nodeName);
  return ApplicationContainer (DoInstall (node));
}

ApplicationContainer
UdpApplicationHelper::Install (NodeContainer c) const
{
  ApplicationContainer apps;
  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
    {
      apps.Add (DoInstall (*i));
    }

  return apps;
}

Ptr<Application>
UdpApplicationHelper::DoInstall (Ptr<Node> node) const
{
  if(node->GetObject<Ipv4> () == NULL)
    {
      InternetStackHelper internet;
      internet.Install (node);
    }

  Ptr<Application> app = m_factory.Create<Application> ();
  node->AddApplication (app);
  app->GetObject<UdpApplication> ()->SetPort (m_port);

  return app;
}

void
UdpApplicationHelper::SetPort (uint16_t port)
{
  m_port = port;
}

} // namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#ifndef UDP_APPLICATION_HELPER_H
#define UDP_APPLICATION_HELPER_H


#include "ns3/object-factory.h"
#include "ns3/attribute.h"
#include "ns3/node-container.h"
#include "ns3/application-container.h"

namespace ns3 {

/**
 * \ingroup applications
 * \brief A helper to make it easier to instantiate an ns3::UdpApplication 
 * on a set of nodes.
 */
class UdpApplicationHelper
{
public:
  /**
   * Create a UdpApplicationHelper to make it easier to work with UdpApplication
   */
  UdpApplicationHelper ();

  /**
   * Helper function used to set the underlying application attributes.
   */
  void SetAttribute (std::string name, const AttributeValue &value);

  /**
   * Install an ns3::UdpApplication on each node of the input container
   * configured with all the attributes set with SetAttribute.
   *
   * \param c NodeContainer of the set of nodes on which a UdpApplication 
   * will be installed.
   * \returns Container of Ptr to the applications installed.
   */
  ApplicationContainer Install (NodeContainer c) const;

  /**
   * Install an ns3::UdpApplication on the node configured with all the 
   * attributes set with SetAttribute.
   *
   * \param node The node on which a UdpApplication will be installed.
   * \returns Container of Ptr to the applications installed.
   */
  ApplicationContainer Install (Ptr<Node> node) const;

  /**
   * Install an ns3::UdpApplication on the node configured with all the 
   * attributes set with SetAttribute.
   *
   * \param nodeName The node on which a UdpApplication will be installed.
   * \returns Container of Ptr to the applications installed.
   */
  ApplicationContainer Install (std::string nodeName) const;

  /**
   * Sets the UDP port number that the UdpApplication will use
   *
   * \param port The UDP port number
   */
  void SetPort (uint16_t port);

private:
  /**
   * Install an ns3::UdpApplication on the node configured with all the 
   * attributes set with SetAttribute.
   *
   * \param node The node on which a UdpApplication will be installed.
   * \returns Ptr to the application installed.
   */
  Ptr<Application> DoInstall (Ptr<Node> node) const;

  ObjectFactory m_factory; //!< Object factory.
  uint16_t m_port;
};

} // namespace ns3

#endif /* UDP_APPLICATION_HELPER_H */





/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */
#include "raw-application.h"
#include "ns3/log.h"
#include "ns3/socket-factory.h"
#include "ns3/packet-socket-address.h"
#include "ns3/packet-socket.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("RawApplication");

NS_OBJECT_ENSURE_REGISTERED (RawApplication);

TypeId 
RawApplication::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::RawApplication")
    .SetParent<Application> ()
    .SetGroupName ("Applications")
    .AddConstructor<RawApplication> ()
  ;
  return tid;
}

RawApplication::RawApplication ()
{
  NS_LOG_FUNCTION (this);
  m_socket = NULL;
  m_packetReceivedCallback.Nullify ();
}
RawApplication::~RawApplication ()
{
  NS_LOG_FUNCTION (this);
}

void
RawApplication::DoDispose (void)
{
  NS_LOG_FUNCTION (this);
  m_socket = NULL;
  m_packetReceivedCallback.Nullify ();
  Application::DoDispose ();
}

uint32_t
RawApplication::GetApplicationId (void) const
{
  NS_LOG_FUNCTION (this);
  Ptr<Node> node = GetNode ();
  for (uint32_t i = 0; i < node->GetNApplications (); ++i)
    {
      if (node->GetApplication (i) == this)
        {
          return i;
        }
    }
  NS_ASSERT_MSG (false, "forgot to add application to node");
  return 0;
}


void 
RawApplication::Send (Address dst, const Buffer dataBuffer)
{
  NS_LOG_FUNCTION (this);
  const uint8_t * data = dataBuffer.PeekData ();
  Address local = GetNode ()->GetDevice (0)->GetAddress ();
  
  if(dst != local)
    { 
      PacketSocketAddress socketAddress;
      socketAddress.SetSingleDevice (GetNode ()->GetDevice (0)->GetIfIndex ());
      socketAddress.SetPhysicalAddress (dst);
      socketAddress.SetProtocol (0);
      Ptr<Packet> packet = Create<Packet> (data, dataBuffer.GetSize ());
      if(m_socket == NULL)
        {
          StartApplication ();
        }
      m_socket->SendTo (packet, 0, socketAddress);
    }
}

void
RawApplication::Receive (Ptr<Socket> socket)
{
  NS_LOG_FUNCTION (this << socket);
  NS_ASSERT (m_socket != NULL);
  while (m_socket->GetRxAvailable () > 0)
    {
      Address srcAddress;
      Ptr<Packet> packet = m_socket->RecvFrom (srcAddress);
      uint8_t *buffer = new uint8_t[packet->GetSize ()];
      packet->CopyData (buffer, packet->GetSize ());
      
      PacketSocketAddress packetSocketAddress = PacketSocketAddress::ConvertFrom (srcAddress);
      srcAddress = packetSocketAddress.GetPhysicalAddress ();
      
      if(!m_packetReceivedCallback.IsNull ())
        {
          Buffer dataBuffer;
          dataBuffer.AddAtEnd ( packet->GetSize ());
          Buffer::Iterator iterator = dataBuffer.Begin ();
          iterator.Write (buffer, packet->GetSize ());
          m_packetReceivedCallback (srcAddress, dataBuffer);
        }
      delete[] buffer;
    }

} 

void 
RawApplication::StartApplication (void)
{
  NS_LOG_FUNCTION (this);
  PacketSocketAddress socketAddress;
  socketAddress.SetSingleDevice (GetNode ()->GetDevice (0)->GetIfIndex ());
  socketAddress.SetProtocol (0);
  if (!m_socket)
    {
      m_socket = Socket::CreateSocket (GetNode (), TypeId::LookupByName ("ns3::PacketSocketFactory"));
    }
  m_socket->Bind ();
  m_socket->Connect (socketAddress);
  m_socket->SetRecvCallback (MakeCallback (&RawApplication::Receive, this));
}
 
void 
RawApplication::StopApplication (void)
{
  NS_LOG_FUNCTION (this);
  if(m_socket != NULL)
    {
      m_socket->Close ();
    }
  else
    {
      NS_LOG_WARN ("RawApplication found null socket to close in StopApplication");
    }
}

void
RawApplication::SetPacketReceivedCallback (PacketReceivedCallback callback)
{
  NS_LOG_FUNCTION (this);
  if (callback.IsNull ())
    {
      NS_LOG_DEBUG ("RawApplication:Setting NULL packet received callback!");
    }
  m_packetReceivedCallback = callback;
}



} // namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#ifndef RAW_APPLICATION_H
#define RAW_APPLICATION_H


#include "ns3/application.h"
#include "ns3/packet.h"
#include "ns3/socket.h"

namespace ns3 {

/**
 * \ingroup applications
 * \brief a simple Raw application.
 * 
 * The Application combines both the client-side and the server-side 
 * functionality, and provides an easy to use bidirectional communications 
 * between the nodes. It runs directly on top of the data link layer, so
 * raw data is sent in the payload of the frame.
 * 
 * The user interacts with the application mainly through two functions:
 * Send () : Used to send the data in the buffer parameter to the
 * destination layer 2 address.
 * SetPacketReceivedCallback (): Used to set a receive callback where the raw 
 * packet payload, and the source layer 2 address will be passed as
 * parameters.
 */

class RawApplication : public Application
{
public:

  typedef Callback<void, Address, Buffer> PacketReceivedCallback;

  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId (void);

  /**
   * create a raw application
   */
  RawApplication ();
  virtual ~RawApplication ();

  /**
   * \brief Send a packet to the destination
   * \param dst the destination address
   * \param dataBuffer the data to be sent
   */
  void Send (Address dst, const Buffer dataBuffer);

  /**
   * \brief Set a callback when a packet is received
   * \param callback the packet received callback
   */
  void SetPacketReceivedCallback (PacketReceivedCallback callback);

private:

  // inherited from Application base class.
  virtual void StartApplication (void);
  virtual void StopApplication (void);
  virtual void DoDispose (void);
  /**
   * \brief Return the application ID in the node.
   * \returns the application id
   */
  uint32_t GetApplicationId (void) const;
  /**
   * \brief Receive a packet
   * \param socket the receiving socket
   *
   * This function is called by lower layers through a callback.
   */
  void Receive (Ptr<Socket> socket);

  Ptr<Socket> m_socket; //!< Associated socket
  PacketReceivedCallback m_packetReceivedCallback;

};

} // namespace ns3

#endif /* RAW_APPLICATION_H */




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */
#include "udp-application.h"
#include "ns3/log.h"
#include "ns3/socket-factory.h"
#include "ns3/packet-socket-address.h"
#include "ns3/packet-socket.h"
#include "ns3/ipv4-l3-protocol.h"
#include "ns3/ipv6-l3-protocol.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("UdpApplication");

NS_OBJECT_ENSURE_REGISTERED (UdpApplication);

TypeId 
UdpApplication::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::UdpApplication")
    .SetParent<Application> ()
    .SetGroupName ("Applications")
    .AddConstructor<UdpApplication> ()
  ;
  return tid;
}

UdpApplication::UdpApplication ()
{
  NS_LOG_FUNCTION (this);
  m_socket = NULL;
  m_packetReceivedCallback.Nullify ();
}
UdpApplication::~UdpApplication ()
{
  NS_LOG_FUNCTION (this);
}

void
UdpApplication::DoDispose (void)
{
  NS_LOG_FUNCTION (this);
  m_socket = NULL;
  m_packetReceivedCallback.Nullify ();
  Application::DoDispose ();
}

uint32_t
UdpApplication::GetApplicationId (void) const
{
  NS_LOG_FUNCTION (this);
  Ptr<Node> node = GetNode ();
  for (uint32_t i = 0; i < node->GetNApplications (); ++i)
    {
      if (node->GetApplication (i) == this)
        {
          return i;
        }
    }
  NS_ASSERT_MSG (false, "forgot to add application to node");
  return 0;
}


void 
UdpApplication::Send (Address dst, const Buffer dataBuffer)
{
  NS_LOG_FUNCTION (this);
  const uint8_t * data = dataBuffer.PeekData ();
  Ptr<Packet> packet = Create<Packet> (data, dataBuffer.GetSize ());
  if(m_socket == NULL)
    {
      StartApplication ();
    }
  
    if(Ipv6Address::IsMatchingType (dst))
      {
        Inet6SocketAddress ipv6_destination = Inet6SocketAddress (Ipv6Address::ConvertFrom (dst), m_port);
        m_socket->SendTo (packet, 0, ipv6_destination);
      }
    else if(Ipv4Address::IsMatchingType (dst))
      {
        InetSocketAddress ipv4_destination = InetSocketAddress (Ipv4Address::ConvertFrom (dst), m_port);
        m_socket->SendTo (packet, 0, ipv4_destination);
      }
}

void
UdpApplication::Receive (Ptr<Socket> socket)
{
  NS_LOG_FUNCTION (this << socket);
  NS_ASSERT (m_socket != NULL);
  Address srcAddress;
  while (m_socket->GetRxAvailable () > 0)
    {
      Ptr<Packet> packet = m_socket->RecvFrom (srcAddress);
      uint8_t *buffer = new uint8_t[packet->GetSize ()];
      packet->CopyData (buffer, packet->GetSize ());
      if(!m_packetReceivedCallback.IsNull ())
        {
          Buffer dataBuffer;
          dataBuffer.AddAtEnd ( packet->GetSize ());
          Buffer::Iterator iterator = dataBuffer.Begin ();
          iterator.Write (buffer, packet->GetSize ());
          
          if(Inet6SocketAddress::IsMatchingType (srcAddress))
            {
              m_packetReceivedCallback (Inet6SocketAddress::ConvertFrom (srcAddress).GetIpv6 (), dataBuffer);
            }
          else if(InetSocketAddress::IsMatchingType (srcAddress))
            {
              m_packetReceivedCallback (InetSocketAddress::ConvertFrom (srcAddress).GetIpv4 (), dataBuffer);
            }
        }
      delete[] buffer;
    }
} 

void 
UdpApplication::StartApplication (void)
{
  NS_LOG_FUNCTION (this);
  if (!m_socket)
    {
      m_socket = Socket::CreateSocket (GetNode (), TypeId::LookupByName ("ns3::UdpSocketFactory"));
    }
  
  if(GetNode ()->GetObject<Ipv6> () != NULL)
    {
      Inet6SocketAddress ipv6_local = Inet6SocketAddress (Ipv6Address::GetAny (), m_port);
      m_socket->Bind (ipv6_local);
    }

  if(GetNode ()->GetObject<Ipv4> () != NULL)
    {
      InetSocketAddress ipv4_local = InetSocketAddress (Ipv4Address::GetAny (), m_port);
      m_socket->Bind (ipv4_local);
    }
  m_socket->SetRecvCallback (MakeCallback (&UdpApplication::Receive, this));
  
}
 
void 
UdpApplication::StopApplication (void)
{
  NS_LOG_FUNCTION (this);
  if(m_socket != NULL)
    {
      m_socket->Close ();
    }
  else
    {
      NS_LOG_WARN ("UdpApplication found null socket to close in StopApplication");
    }
}

void
UdpApplication::SetPacketReceivedCallback (PacketReceivedCallback callback)
{
  NS_LOG_FUNCTION (this);
  if (callback.IsNull ())
    {
      NS_LOG_DEBUG ("UdpApplication:Setting NULL packet received callback!");
    }
  m_packetReceivedCallback = callback;
}

void
UdpApplication::SetPort (uint16_t port)
{
  m_port = port;
}

uint16_t
UdpApplication::GetPort () const
{
  return m_port;
}

} // namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 * 
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#ifndef UDP_APPLICATION_H
#define UDP_APPLICATION_H


#include "ns3/application.h"
#include "ns3/packet.h"
#include "ns3/mac8-address.h"
#include "ns3/socket.h"

namespace ns3 {

/**
 * \ingroup applications
 * \brief a simple UDP application.
 * 
 * The Application uses the NS-3 IP stack, and UDP Sockets to send and received
 * data.
 * The user interacts with the application mainly through two functions:
 * Send () : Used to send the data in the buffer parameter to the
 * destination IPv4/IPv6 address.
 * SetPacketReceivedCallback (): Used to set a receive callback where the raw 
 * packet payload, and the source IPv4/IPv6 address will be passed as
 * parameters.
 */

class UdpApplication : public Application
{
public:

  typedef Callback<void, Address, Buffer> PacketReceivedCallback;

  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId (void);

  /**
   * create a udp application
   */
  UdpApplication ();
  virtual ~UdpApplication ();

  /**
   * \brief Send a packet to the destination
   * \param dst the destination IPv4 address
   * \param dataBuffer the data to be sent
   */
  void Send (Address dst, const Buffer dataBuffer);

  /**
   * \brief Set a callback when a packet is received
   * \param callback the packet received callback
   */
  void SetPacketReceivedCallback (PacketReceivedCallback callback);

  /**
   * \brief Sets the UDP port number.
   * \param port The UDP port number
   */
  void SetPort (uint16_t port);
  
  /**
   * \brief Gets the UDP port number.
   * \return The UDP port number
   */
  uint16_t GetPort () const;

private:

  // inherited from Application base class.
  virtual void StartApplication (void);
  virtual void StopApplication (void);
  virtual void DoDispose (void);
  /**
   * \brief Return the application ID in the node.
   * \returns the application id
   */
  uint32_t GetApplicationId (void) const;
  /**
   * \brief Receive a packet
   * \param socket the receiving socket
   *
   * This function is called by lower layers through a callback.
   */
  void Receive (Ptr<Socket> socket);

  Ptr<Socket> m_socket; //!< Associated socket
  uint16_t m_port;      //!< Port number
  PacketReceivedCallback m_packetReceivedCallback;

};

} // namespace ns3

#endif /* UDP_APPLICATION_H */

(-)a/src/applications/wscript (+8 lines)

Lines 14-24 def build(bld):	Link Here

        'model/udp-echo-client.cc',

        'model/udp-echo-client.cc',

        'model/udp-echo-server.cc',

        'model/udp-echo-server.cc',

        'model/application-packet-probe.cc',

        'model/application-packet-probe.cc',

        'model/udp-application.cc',

        'model/raw-application.cc',

        'helper/bulk-send-helper.cc',

        'helper/bulk-send-helper.cc',

        'helper/on-off-helper.cc',

        'helper/on-off-helper.cc',

        'helper/packet-sink-helper.cc',

        'helper/packet-sink-helper.cc',

        'helper/udp-client-server-helper.cc',

        'helper/udp-client-server-helper.cc',

        'helper/udp-echo-helper.cc',

        'helper/udp-echo-helper.cc',

        'helper/udp-application-helper.cc',

        'helper/raw-application-helper.cc',

    applications_test = bld.create_ns3_module_test_library('applications')

    applications_test = bld.create_ns3_module_test_library('applications')

Lines 40-50 def build(bld):	Link Here

        'model/udp-echo-client.h',

        'model/udp-echo-client.h',

        'model/udp-echo-server.h',

        'model/udp-echo-server.h',

        'model/application-packet-probe.h',

        'model/application-packet-probe.h',

        'model/udp-application.h',

        'model/raw-application.h',

        'helper/bulk-send-helper.h',

        'helper/bulk-send-helper.h',

        'helper/on-off-helper.h',

        'helper/on-off-helper.h',

        'helper/packet-sink-helper.h',

        'helper/packet-sink-helper.h',

        'helper/udp-client-server-helper.h',

        'helper/udp-client-server-helper.h',

        'helper/udp-echo-helper.h',

        'helper/udp-echo-helper.h',

        'helper/udp-application-helper.h',

        'helper/raw-application-helper.h',

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/internet/helper/ipv6-address-helper.cc (-1 / +7 lines)

Lines 104-112 Ipv6Address Ipv6AddressHelper::NewAddress (Address addr)	Link Here

104

      Ipv6AddressGenerator::AddAllocated (address);

104

      Ipv6AddressGenerator::AddAllocated (address);

105

      return address;

105

      return address;

106

107

  else if (Mac8Address::IsMatchingType (addr))

108

109

      Ipv6Address address = Ipv6Address::MakeAutoconfiguredAddress (Mac8Address::ConvertFrom (addr), m_network);

110

      Ipv6AddressGenerator::AddAllocated (address);

111

      return address;

112

107

  else

113

  else

108

114

109

      NS_FATAL_ERROR ("Did not pass in a valid Mac Address (16, 48 or 64 bits)");

115

      NS_FATAL_ERROR ("Did not pass in a valid Mac Address (8, 16, 48 or 64 bits)");

110

116

111

  /* never reached */

117

  /* never reached */

112

  return Ipv6Address ("::");

118

  return Ipv6Address ("::");

(-)a/src/internet/model/arp-header.cc (-1 / +1 lines)

Lines 136-142 uint32_t	Link Here

136

ArpHeader::GetSerializedSize (void) const

136

ArpHeader::GetSerializedSize (void) const

137

138

  NS_LOG_FUNCTION (this);

138

  NS_LOG_FUNCTION (this);

139

  NS_ASSERT((m_macSource.GetLength () == 6) || (m_macSource.GetLength () == 8));

139

  NS_ASSERT ((m_macSource.GetLength () == 6) || (m_macSource.GetLength () == 8) || (m_macSource.GetLength () == 1));

140

  NS_ASSERT (m_macSource.GetLength () == m_macDest.GetLength ());

140

  NS_ASSERT (m_macSource.GetLength () == m_macDest.GetLength ());

141

142

  uint32_t length = 16;   // Length minus two hardware addresses

142

  uint32_t length = 16;   // Length minus two hardware addresses

(-)a/src/internet/model/ipv6-interface.cc (+6 lines)

Lines 113-118 void Ipv6Interface::DoSetup ()	Link Here

113

          AddAddress (ifaddr);

113

          AddAddress (ifaddr);

114

          m_linkLocalAddress = ifaddr;

114

          m_linkLocalAddress = ifaddr;

115

116

      else if (Mac8Address::IsMatchingType (addr))

117

118

          Ipv6InterfaceAddress ifaddr = Ipv6InterfaceAddress (Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac8Address::ConvertFrom (addr)), Ipv6Prefix (64));

119

          AddAddress (ifaddr);

120

          m_linkLocalAddress = ifaddr;

121

116

      else

122

      else

117

123

118

          NS_FATAL_ERROR ("IPv6 autoconf for this kind of address not implemented.");

124

          NS_FATAL_ERROR ("IPv6 autoconf for this kind of address not implemented.");




  return ret;
}

Ipv6Address Ipv6Address::MakeAutoconfiguredAddress (Mac8Address addr, Ipv6Address prefix)
{
  NS_LOG_FUNCTION (addr << prefix);
  Ipv6Address ret;
  uint8_t buf[2];
  uint8_t buf2[16];

  buf[0] = 0;
  addr.CopyTo (&buf[1]);
  prefix.GetBytes (buf2);

  memcpy (buf2 + 14, buf, 2);
  buf2[11] = 0xff;
  buf2[12] = 0xfe;

  ret.Set (buf2);
  return ret;
}

Ipv6Address Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac16Address addr)
{
  NS_LOG_FUNCTION (addr);

  return ret;
}

Ipv6Address Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac8Address addr)
{
  NS_LOG_FUNCTION (addr);
  Ipv6Address ret;
  uint8_t buf[2];
  uint8_t buf2[16];

  buf[0] = 0;
  addr.CopyTo (&buf[1]);

  memset (buf2, 0x00, sizeof (buf2));
  buf2[0] = 0xfe;
  buf2[1] = 0x80;
  memcpy (buf2 + 14, buf, 2);
  buf2[11] = 0xff;
  buf2[12] = 0xfe;

  ret.Set (buf2);
  return ret;
}

Ipv6Address Ipv6Address::MakeSolicitedAddress (Ipv6Address addr)
{
  NS_LOG_FUNCTION (addr);

(-)a/src/network/utils/ipv6-address.h (+16 lines)

Lines 30-35	Link Here

#include "ns3/address.h"

#include "ns3/address.h"

#include "ns3/ipv4-address.h"

#include "ns3/ipv4-address.h"

#include "ns3/deprecated.h"

#include "ns3/deprecated.h"

#include "mac8-address.h"

namespace ns3 {

namespace ns3 {

Lines 163-168 public:	Link Here

163

*/

164

*/

164

  static Ipv6Address MakeAutoconfiguredAddress (Mac64Address addr, Ipv6Address prefix);

165

  static Ipv6Address MakeAutoconfiguredAddress (Mac64Address addr, Ipv6Address prefix);

165

166

167

/**

168

   * \brief Make the autoconfigured IPv6 address with Mac8Address.

169

   * \param addr the Mac8Address address (8 bits).

170

   * \param prefix the IPv6 prefix

171

   * \return autoconfigured IPv6 address

172

*/

173

  static Ipv6Address MakeAutoconfiguredAddress (Mac8Address addr, Ipv6Address prefix);

174

166

/**

175

/**

167

   * \brief Make the autoconfigured link-local IPv6 address with Mac16Address.

176

   * \brief Make the autoconfigured link-local IPv6 address with Mac16Address.

168

   * \param mac the MAC address (16 bits).

177

   * \param mac the MAC address (16 bits).

Lines 184-189 public:	Link Here

184

*/

193

*/

185

  static Ipv6Address MakeAutoconfiguredLinkLocalAddress (Mac64Address mac);

194

  static Ipv6Address MakeAutoconfiguredLinkLocalAddress (Mac64Address mac);

186

195

196

/**

197

   * \brief Make the autoconfigured link-local IPv6 address with Mac8Address.

198

   * \param mac the MAC address (8 bits).

199

   * \return autoconfigured link-local IPv6 address

200

*/

201

  static Ipv6Address MakeAutoconfiguredLinkLocalAddress (Mac8Address mac);

202

187

/**

203

/**

188

   * \brief Print this address to the given output stream.

204

   * \brief Print this address to the given output stream.

189

205




 * Author: Leonard Tracy <lentracy@gmail.com>
 */

#include "mac8-address.h"
#include "ns3/address.h"

namespace ns3 {

Mac8Address::Mac8Address ()
{
  m_address = 255;
}

Mac8Address::Mac8Address (uint8_t addr)
  : m_address (addr)
{
}

Mac8Address::~Mac8Address ()
{
}

uint8_t
Mac8Address::GetType (void)
{
  static uint8_t type = Address::Register ();
  return type;
}

Address
Mac8Address::ConvertTo (void) const
{
  return Address (GetType (), &m_address, 1);
}

Mac8Address
Mac8Address::ConvertFrom (const Address &address)
{
  NS_ASSERT (IsMatchingType (address));
  Mac8Address uAddr;
  address.CopyTo (&uAddr.m_address);
  return uAddr;
}

uint8_t
UanAddress::GetAsInt (void) const
{
  return m_address;
}
bool
Mac8Address::IsMatchingType (const Address &address)
{
  return address.CheckCompatible (GetType (), 1);
}

Mac8Address::operator Address () const
{
  return ConvertTo ();
}

void
Mac8Address::CopyFrom (const uint8_t *pBuffer)
{
  m_address = *pBuffer;
}

void
Mac8Address::CopyTo (uint8_t *pBuffer) const
{
  *pBuffer = m_address;

}

Mac8Address
Mac8Address::GetBroadcast ()
{
  return Mac8Address (255);
}
Mac8Address
Mac8Address::Allocate ()
{
  static uint8_t nextAllocated = 0;


      nextAllocated = 0;
    }

  return Mac8Address (address);
}

bool
operator < (const Mac8Address &a, const Mac8Address &b)
{
  return a.m_address < b.m_address;
}

bool
operator == (const Mac8Address &a, const Mac8Address &b)
{
  return a.m_address == b.m_address;
}

bool
operator != (const Mac8Address &a, const Mac8Address &b)
{
  return !(a == b);
}

std::ostream&
operator<< (std::ostream& os, const Mac8Address & address)
{
  os << (int) address.m_address;
  return os;
}
std::istream&
operator>> (std::istream& is, Mac8Address & address)
{
  int x;
  is >> x;




 * Author: Leonard Tracy <lentracy@gmail.com>
 */

#ifndef MAC8_ADDRESS_H
#define MAC8_ADDRESS_H

#include "ns3/address.h"
#include <iostream>

namespace ns3 {

class Address;

/**
 * \ingroup network
 *
 * A class used for addressing MAC8 MAC's.
 *
 * This implementation uses a simple 8 bit flat addressing scheme.
 * It is unlikely that perceived underwater networks will soon

 * - the ocean is big), so this should provide adequate addressing
 * for most applications.
 */
class Mac8Address
{
public:
  /** Constructor */
  Mac8Address ();
  /**
   * Create Mac8Address object with address addr.
   *
   * \param addr Byte address to assign to this address.
   */
  Mac8Address (uint8_t addr);
  /** Destructor */
  virtual ~Mac8Address ();

  /**
   * Convert a generic address to a Mac8Address.
   *
   * \param address  Address to convert to Mac8Address address.
   * \return Mac8Address from Address.
   */
  static Mac8Address ConvertFrom (const Address &address);

  /**
   * Check that a generic Address is compatible with Mac8Address.
   *
   * \param address  Address to test.
   * \return True if address given is consistant with Mac8Address.
   */
  static bool IsMatchingType  (const Address &address);


   *
   * \param pBuffer
   */
  void CopyTo (uint8_t *pBuffer) const;

  /**
   * Convert to integer.
   *
   * \return 8 bit integer version of address.
   */
  uint8_t GetAsInt (void) const;

  /**
   * Get the broadcast address (255).
   *
   * \return Broadcast address.
   */
  static Mac8Address GetBroadcast (void);

  /**
   * Allocates Mac8Address from 0-254
   *
   * Will wrap back to 0 if more than 254 are allocated.
   * Excludes the broadcast address.
   *
   * \return The next sequential Mac8Address.
   */
  static Mac8Address Allocate ();


private:
  uint8_t m_address;  //!< The address.

  /**
   * Get the Mac8Address type.
   *
   * \return The type value.
   */

   */
  Address ConvertTo (void) const;

  friend bool operator <  (const Mac8Address &a, const Mac8Address &b);
  friend bool operator == (const Mac8Address &a, const Mac8Address &b);
  friend bool operator != (const Mac8Address &a, const Mac8Address &b);
  friend std::ostream& operator<< (std::ostream& os, const Mac8Address & address);
  friend std::istream& operator>> (std::istream& is, Mac8Address & address);

};  // class Mac8Address


/**

 * \param b Second address to compare.
 * \return True if a < b.
 */
bool operator < (const Mac8Address &a, const Mac8Address &b);

/**
 * Address comparison, equalit.

 * \param b Second address to compare.
 * \return True if a == b.
 */
bool operator == (const Mac8Address &a, const Mac8Address &b);

/**
 * Address comparison, unequal.

 * \param b Second address to compare.
 * \return True if a != b.
 */
bool operator != (const Mac8Address &a, const Mac8Address &b);

/**
 * Write \pname{address} to stream \pname{os} as 8 bit integer.

 * \param address The address
 * \return The output stream.
 */
std::ostream& operator<< (std::ostream& os, const Mac8Address & address);

/**
 * Read \pname{address} from stream \pname{is} as 8 bit integer.

 * \param address The address variable to set.
 * \return The input stream.
 */
std::istream& operator>> (std::istream& is, Mac8Address & address);

} // namespace ns3

#endif /* MAC8_ADDRESS_H */

(-)a/src/network/wscript (+2 lines)

Lines 62-67 def build(bld):	Link Here

        'utils/packet-socket-server.cc',

        'utils/packet-socket-server.cc',

        'utils/packet-data-calculators.cc',

        'utils/packet-data-calculators.cc',

        'utils/packet-probe.cc',

        'utils/packet-probe.cc',

        'utils/mac8-address.cc',

        'helper/application-container.cc',

        'helper/application-container.cc',

        'helper/net-device-container.cc',

        'helper/net-device-container.cc',

        'helper/node-container.cc',

        'helper/node-container.cc',

Lines 152-157 def build(bld):	Link Here

152

        'utils/pcap-test.h',

153

        'utils/pcap-test.h',

153

        'utils/packet-data-calculators.h',

154

        'utils/packet-data-calculators.h',

154

        'utils/packet-probe.h',

155

        'utils/packet-probe.h',

156

        'utils/mac8-address.h',

155

        'helper/application-container.h',

157

        'helper/application-container.h',

156

        'helper/net-device-container.h',

158

        'helper/net-device-container.h',

157

        'helper/node-container.h',

159

        'helper/node-container.h',

(-)a/src/sixlowpan/model/sixlowpan-net-device.cc (+4 lines)

Lines 2099-2104 Ipv6Address SixLowPanNetDevice::MakeLinkLocalAddressFromMac (Address const &addr	Link Here

2099

2100

          ipv6Addr = Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac16Address::ConvertFrom (addr));

2100

          ipv6Addr = Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac16Address::ConvertFrom (addr));

2101

2102

      else if (Mac8Address::IsMatchingType (addr))

2103

2104

          ipv6Addr = Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac8Address::ConvertFrom (addr));

2105

2102

2106

2103

  if (ipv6Addr.IsAny ())

2107

  if (ipv6Addr.IsAny ())

2104

2108

(-)a/src/test/traced/traced-callback-typedef-test-suite.cc (-1 / +1 lines)

Lines 635-641 TracedCallbackTypedefTestCase::DoRun (void)	Link Here

635

         empty, empty, empty);

635

         empty, empty, empty);

636

637

  CHECK (UanNetDevice::RxTxTracedCallback,

637

  CHECK (UanNetDevice::RxTxTracedCallback,

638

         Ptr<const Packet>, UanAddress,

638

         Ptr<const Packet>, Mac8Address,

639

         empty, empty, empty);

639

         empty, empty, empty);

640

641

  CHECK (UanPhy::TracedCallback,

641

  CHECK (UanPhy::TracedCallback,




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 *
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#include "ns3/core-module.h"
#include "ns3/internet-module.h"
#include "ns3/node-container.h"
#include "ns3/mobility-helper.h"
#include "ns3/mobility-model.h"
#include "ns3/basic-energy-source-helper.h"
#include "ns3/energy-source-container.h"
#include "ns3/uan-helper.h"
#include "ns3/uan-channel.h"
#include "ns3/acoustic-modem-energy-model-helper.h"
#include "ns3/udp-application-helper.h"
#include "ns3/udp-application.h"
#include "ns3/sixlowpan-helper.h"
#include "ns3/sixlowpan-net-device.h"

using namespace ns3;

/**
 *
 * This example shows the usage of UdpApplication to transfer data.
 * Two nodes are sending their remaining energy percentage (1 byte)
 * to a gateway node, that prints the received data.
 * The transmissions are scheduled at random times to avoid collisions
 *
 */

NS_LOG_COMPONENT_DEFINE ("Uan6lowpanExample");

void SetupPositions ();
void SetupEnergy ();
void SetupCommunications ();
void PrintReceivedPacket (Address src, Buffer data);
void SetupApplications ();
void SendPacket ();
void Run ();

NodeContainer nodeContainer;

void
SetupPositions ()
{
  MobilityHelper mobilityHelper;
  mobilityHelper.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobilityHelper.Install (nodeContainer);
  nodeContainer.Get (0)->GetObject<MobilityModel> ()->SetPosition (Vector (0, 0, 0));
  nodeContainer.Get (1)->GetObject<MobilityModel> ()->SetPosition (Vector (100, 0, 0));
  nodeContainer.Get (2)->GetObject<MobilityModel> ()->SetPosition (Vector (-100, 0, 0));
}

void
SetupEnergy ()
{
  BasicEnergySourceHelper energySourceHelper;
  energySourceHelper.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (900000));
  energySourceHelper.Install (nodeContainer);
}

void
SetupCommunications ()
{
  Ptr<UanChannel> channel = CreateObject<UanChannel> ();
  UanHelper uanHelper;
  NetDeviceContainer netDeviceContainer = uanHelper.Install (nodeContainer, channel);
  EnergySourceContainer energySourceContainer;
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      energySourceContainer.Add ((*node)->GetObject<EnergySourceContainer> ()->Get (0));
      node++;
    }
  AcousticModemEnergyModelHelper acousticModemEnergyModelHelper;
  acousticModemEnergyModelHelper.Install (netDeviceContainer, energySourceContainer);

  SixLowPanHelper sixLowPanHelper;
  NetDeviceContainer sixlowpanNetDevices = sixLowPanHelper.Install (netDeviceContainer);
  
  InternetStackHelper internetStackHelper;
  internetStackHelper.Install (nodeContainer);
  
  Ipv6AddressHelper ipv6AddressHelper;
  ipv6AddressHelper.SetBase (Ipv6Address ("2002::"), Ipv6Prefix (64));
  ipv6AddressHelper.Assign (sixlowpanNetDevices);
  
  node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      (*node)->GetObject<Icmpv6L4Protocol> ()->SetAttribute("DAD", BooleanValue(false));
      (*node)->GetObject<Icmpv6L4Protocol> ()->SetAttribute("ReachableTime", TimeValue (Seconds (3600)));
      (*node)->GetObject<Icmpv6L4Protocol> ()->SetAttribute("RetransmissionTime", TimeValue (Seconds (1000)));
      node++;
    }
}

void
PrintReceivedPacket (Address src, Buffer data)
{
  std::cout << "Time:" << Simulator::Now ().GetDays () << "|"
            << "Node:" << Ipv6Address::ConvertFrom (src)
            << "|Energy:" << (int)(data.Begin ().ReadU8 ()) << "%" << std::endl;
}

void
SetupApplications ()
{
  UdpApplicationHelper udpApplicationHelper;
  ApplicationContainer applicationContainer;
  udpApplicationHelper.SetPort (9);
  applicationContainer = udpApplicationHelper.Install (nodeContainer);
  applicationContainer.Start (Seconds (0));
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      Ptr<UdpApplication> udpApplication = (*node)->GetApplication (0)->GetObject<UdpApplication> ();
      udpApplication->SetPacketReceivedCallback (MakeCallback<void, Address, Buffer>(&PrintReceivedPacket));
      node++;
    }
}

void
SendPacket ()
{
  Ptr<UniformRandomVariable> uniformRandomVariable = CreateObject<UniformRandomVariable> ();
  NodeContainer::Iterator node = nodeContainer.Begin ();
  Ipv6Address dst = (*node)->GetObject<Ipv6L3Protocol> ()->GetInterface (1)->GetAddress (1).GetAddress ();
  node++;
  while (node != nodeContainer.End ())
    {
      uint8_t energy = ((*node)->GetObject<EnergySourceContainer> ()->Get (0)->GetEnergyFraction ()) * 100;
      Ptr<UdpApplication> udpApplication = (*node)->GetApplication (0)->GetObject<UdpApplication> ();
      Buffer dataBuffer;
      dataBuffer.AddAtEnd (sizeof (uint8_t));
      Buffer::Iterator i = dataBuffer.Begin ();
      i.WriteU8 (energy);
      double time = uniformRandomVariable->GetValue (0, 60);
      Simulator::Schedule (Seconds (time), &UdpApplication::Send, udpApplication, dst, dataBuffer);
      node++;
    }
  Simulator::Schedule (Hours (2), &SendPacket);
}

void
Run ()
{
  nodeContainer.Create (3);
  SetupPositions ();
  SetupEnergy ();
  SetupCommunications ();
  SetupApplications ();
  SendPacket ();
}

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);
  Run ();
  Simulator::Stop (Days (50));
  Simulator::Run ();
  Simulator::Destroy ();

  return 0;
}




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 *
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#include "ns3/core-module.h"
#include "ns3/node-container.h"
#include "ns3/mobility-helper.h"
#include "ns3/mobility-model.h"
#include "ns3/basic-energy-source-helper.h"
#include "ns3/energy-source-container.h"
#include "ns3/uan-helper.h"
#include "ns3/uan-channel.h"
#include "ns3/acoustic-modem-energy-model-helper.h"
#include "ns3/udp-application-helper.h"
#include "ns3/udp-application.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-interface.h"
#include "ns3/arp-cache.h"

using namespace ns3;

/**
 *
 * This example shows the usage of UdpApplication to transfer data.
 * Two nodes are sending their remaining energy percentage (1 byte)
 * to a gateway node, that prints the received data.
 * The transmissions are scheduled at random times to avoid collisions
 * ARP parameters should be tuned, based on the network size
 *
 */

NS_LOG_COMPONENT_DEFINE ("UanIpv4Example");

void SetupPositions ();
void SetupEnergy ();
void SetupCommunications ();
void PrintReceivedPacket (Address src, Buffer data);
void SetupApplications ();
void SendPacket ();
void Run ();

NodeContainer nodeContainer;

void
SetupPositions ()
{
  MobilityHelper mobilityHelper;
  mobilityHelper.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobilityHelper.Install (nodeContainer);
  nodeContainer.Get (0)->GetObject<MobilityModel> ()->SetPosition (Vector (0, 0, 0));
  nodeContainer.Get (1)->GetObject<MobilityModel> ()->SetPosition (Vector (100, 0, 0));
  nodeContainer.Get (2)->GetObject<MobilityModel> ()->SetPosition (Vector (-100, 0, 0));
}

void
SetupEnergy ()
{
  BasicEnergySourceHelper energySourceHelper;
  energySourceHelper.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (900000));
  energySourceHelper.Install (nodeContainer);
}

void
SetupCommunications ()
{
  Ptr<UanChannel> channel = CreateObject<UanChannel> ();
  UanHelper uanHelper;
  NetDeviceContainer netDeviceContainer = uanHelper.Install (nodeContainer, channel);
  EnergySourceContainer energySourceContainer;
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      energySourceContainer.Add ((*node)->GetObject<EnergySourceContainer> ()->Get (0));
      node++;
    }
  AcousticModemEnergyModelHelper acousticModemEnergyModelHelper;
  acousticModemEnergyModelHelper.Install (netDeviceContainer, energySourceContainer);

  InternetStackHelper internetStackHelper;
  internetStackHelper.Install (nodeContainer);
  Ipv4AddressHelper ipv4AddressHelper;
  ipv4AddressHelper.SetBase ("10.0.0.0", "255.255.255.0");  
  ipv4AddressHelper.Assign (netDeviceContainer);

  node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      (*node)->GetObject<Ipv4L3Protocol> ()->GetInterface (1)->GetArpCache ()->SetWaitReplyTimeout (Seconds (10));
      node++;
    }
}

void
PrintReceivedPacket (Address src, Buffer data)
{
  std::cout << "Time:" << Simulator::Now ().GetDays () << "|"
            << "Node:" << Ipv4Address::ConvertFrom (src)
            << "|Energy:" << (int)(data.Begin ().ReadU8 ()) << "%" << std::endl;
}

void
SetupApplications ()
{
  UdpApplicationHelper udpApplicationHelper;
  ApplicationContainer applicationContainer;
  udpApplicationHelper.SetPort (9);
  applicationContainer = udpApplicationHelper.Install (nodeContainer);
  applicationContainer.Start (Seconds (0));
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      Ptr<UdpApplication> udpApplication = (*node)->GetApplication (0)->GetObject<UdpApplication> ();
      udpApplication->SetPacketReceivedCallback (MakeCallback<void, Address, Buffer>(&PrintReceivedPacket));
      node++;
    }
}

void
SendPacket ()
{
  Ptr<UniformRandomVariable> uniformRandomVariable = CreateObject<UniformRandomVariable> ();
  NodeContainer::Iterator node = nodeContainer.Begin ();
  Ipv4Address dst = (*node)->GetObject<Ipv4L3Protocol> ()->GetInterface (1)->GetAddress (0).GetLocal ();
  node++;
  while (node != nodeContainer.End ())
    {
      uint8_t energy = ((*node)->GetObject<EnergySourceContainer> ()->Get (0)->GetEnergyFraction ()) * 100;
      Ptr<UdpApplication> udpApplication = (*node)->GetApplication (0)->GetObject<UdpApplication> ();
      Buffer dataBuffer;
      dataBuffer.AddAtEnd (sizeof (uint8_t));
      Buffer::Iterator i = dataBuffer.Begin ();
      double time = uniformRandomVariable->GetValue (0, 15);
      i.WriteU8 (energy);
      Simulator::Schedule (Seconds (time), &UdpApplication::Send, udpApplication, dst, dataBuffer);
      node++;
    }
  Simulator::Schedule (Minutes (5), &SendPacket);
}

void
Run ()
{
  nodeContainer.Create (3);
  SetupPositions ();
  SetupEnergy ();
  SetupCommunications ();
  SetupApplications ();
  SendPacket ();
}

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);
  Run ();
  Simulator::Stop (Days (10));
  Simulator::Run ();
  Simulator::Destroy ();

  return 0;
}




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 *
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#include "ns3/core-module.h"
#include "ns3/internet-module.h"
#include "ns3/node-container.h"
#include "ns3/mobility-helper.h"
#include "ns3/mobility-model.h"
#include "ns3/basic-energy-source-helper.h"
#include "ns3/energy-source-container.h"
#include "ns3/uan-helper.h"
#include "ns3/uan-channel.h"
#include "ns3/acoustic-modem-energy-model-helper.h"
#include "ns3/udp-application-helper.h"
#include "ns3/udp-application.h"

using namespace ns3;

/**
 *
 * This example shows the usage of UdpApplication to transfer data.
 * Two nodes are sending their remaining energy percentage (1 byte)
 * to a gateway node, that prints the received data.
 * The transmissions are scheduled at random times to avoid collisions
 *
 */

NS_LOG_COMPONENT_DEFINE ("UanIpv6Example");

void SetupPositions ();
void SetupEnergy ();
void SetupCommunications ();
void PrintReceivedPacket (Address src, Buffer data);
void SetupApplications ();
void SendPacket ();
void Run ();

NodeContainer nodeContainer;

void
SetupPositions ()
{
  MobilityHelper mobilityHelper;
  mobilityHelper.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobilityHelper.Install (nodeContainer);
  nodeContainer.Get (0)->GetObject<MobilityModel> ()->SetPosition (Vector (0, 0, 0));
  nodeContainer.Get (1)->GetObject<MobilityModel> ()->SetPosition (Vector (100, 0, 0));
  nodeContainer.Get (2)->GetObject<MobilityModel> ()->SetPosition (Vector (-100, 0, 0));
}

void
SetupEnergy ()
{
  BasicEnergySourceHelper energySourceHelper;
  energySourceHelper.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (900000));
  energySourceHelper.Install (nodeContainer);
}

void
SetupCommunications ()
{
  Ptr<UanChannel> channel = CreateObject<UanChannel> ();
  UanHelper uanHelper;
  NetDeviceContainer netDeviceContainer = uanHelper.Install (nodeContainer, channel);
  EnergySourceContainer energySourceContainer;
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      energySourceContainer.Add ((*node)->GetObject<EnergySourceContainer> ()->Get (0));
      node++;
    }
  AcousticModemEnergyModelHelper acousticModemEnergyModelHelper;
  acousticModemEnergyModelHelper.Install (netDeviceContainer, energySourceContainer);

  InternetStackHelper internetStackHelper;
  internetStackHelper.Install (nodeContainer);
  
  Ipv6AddressHelper ipv6AddressHelper;
  ipv6AddressHelper.SetBase (Ipv6Address ("2002::"), Ipv6Prefix (64));
  ipv6AddressHelper.Assign (netDeviceContainer);
  
  node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      (*node)->GetObject<Icmpv6L4Protocol> ()->SetAttribute("DAD", BooleanValue(false));
      (*node)->GetObject<Icmpv6L4Protocol> ()->SetAttribute("ReachableTime", TimeValue (Seconds (3600)));
      (*node)->GetObject<Icmpv6L4Protocol> ()->SetAttribute("RetransmissionTime", TimeValue (Seconds (1000)));
      node++;
    }
}

void
PrintReceivedPacket (Address src, Buffer data)
{
  std::cout << "Time:" << Simulator::Now ().GetDays () << "|"
            << "Node:" << Ipv6Address::ConvertFrom (src)
            << "|Energy:" << (int)(data.Begin ().ReadU8 ()) << "%" << std::endl;
}

void
SetupApplications ()
{
  UdpApplicationHelper udpApplicationHelper;
  ApplicationContainer applicationContainer;
  udpApplicationHelper.SetPort (9);
  applicationContainer = udpApplicationHelper.Install (nodeContainer);
  applicationContainer.Start (Seconds (0));
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      Ptr<UdpApplication> udpApplication = (*node)->GetApplication (0)->GetObject<UdpApplication> ();
      udpApplication->SetPacketReceivedCallback (MakeCallback<void, Address, Buffer>(&PrintReceivedPacket));
      node++;
    }
}

void
SendPacket ()
{
  Ptr<UniformRandomVariable> uniformRandomVariable = CreateObject<UniformRandomVariable> ();
  NodeContainer::Iterator node = nodeContainer.Begin ();
  Ipv6Address dst = (*node)->GetObject<Ipv6L3Protocol> ()->GetInterface (1)->GetAddress (1).GetAddress ();
  node++;
  while (node != nodeContainer.End ())
    {
      uint8_t energy = ((*node)->GetObject<EnergySourceContainer> ()->Get (0)->GetEnergyFraction ()) * 100;
      Ptr<UdpApplication> udpApplication = (*node)->GetApplication (0)->GetObject<UdpApplication> ();
      Buffer dataBuffer;
      dataBuffer.AddAtEnd (sizeof (uint8_t));
      Buffer::Iterator i = dataBuffer.Begin ();
      double time = uniformRandomVariable->GetValue (0, 120);
      i.WriteU8 (energy);
      Simulator::Schedule (Seconds (time), &UdpApplication::Send, udpApplication, dst, dataBuffer);
      node++;
    }
  Simulator::Schedule (Hours (2), &SendPacket);
}

void
Run ()
{
  nodeContainer.Create (3);
  SetupPositions ();
  SetupEnergy ();
  SetupCommunications ();
  SetupApplications ();
  SendPacket ();
}

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);
  Run ();
  Simulator::Stop (Days (30));
  Simulator::Run ();
  Simulator::Destroy ();

  return 0;
}




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 *
 * Author: Hossam Khader <hossamkhader@gmail.com>
 */

#include "ns3/core-module.h"
#include "ns3/node-container.h"
#include "ns3/mobility-helper.h"
#include "ns3/mobility-model.h"
#include "ns3/basic-energy-source-helper.h"
#include "ns3/energy-source-container.h"
#include "ns3/uan-helper.h"
#include "ns3/uan-channel.h"
#include "ns3/acoustic-modem-energy-model-helper.h"
#include "ns3/raw-application-helper.h"
#include "ns3/raw-application.h"

using namespace ns3;

/**
 *
 * This example shows the usage of RawApplication to transfer data.
 * Two nodes are sending their remaining energy percentage (1 byte)
 * to a gateway node, that prints the received data.
 * The transmissions are scheduled at random times to avoid collisions
 *
 */

NS_LOG_COMPONENT_DEFINE ("UanRawExample");

void SetupPositions ();
void SetupEnergy ();
void SetupCommunications ();
void PrintReceivedPacket (Address src, Buffer data);
void SetupApplications ();
void SendPacket ();
void Run ();

NodeContainer nodeContainer;

void
SetupPositions ()
{
  MobilityHelper mobilityHelper;
  mobilityHelper.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobilityHelper.Install (nodeContainer);
  nodeContainer.Get (0)->GetObject<MobilityModel> ()->SetPosition (Vector (0, 0, 0));
  nodeContainer.Get (1)->GetObject<MobilityModel> ()->SetPosition (Vector (100, 0, 0));
  nodeContainer.Get (2)->GetObject<MobilityModel> ()->SetPosition (Vector (-100, 0, 0));
}

void
SetupEnergy ()
{
  BasicEnergySourceHelper energySourceHelper;
  energySourceHelper.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (900000));
  energySourceHelper.Install (nodeContainer);
}

void
SetupCommunications ()
{
  Ptr<UanChannel> channel = CreateObject<UanChannel> ();
  UanHelper uanHelper;
  NetDeviceContainer netDeviceContainer = uanHelper.Install (nodeContainer, channel);
  EnergySourceContainer energySourceContainer;
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      energySourceContainer.Add ((*node)->GetObject<EnergySourceContainer> ()->Get (0));
      node++;
    }
  AcousticModemEnergyModelHelper acousticModemEnergyModelHelper;
  acousticModemEnergyModelHelper.Install (netDeviceContainer, energySourceContainer);
}

void
PrintReceivedPacket (Address src, Buffer data)
{
  std::cout << "Time:" << Simulator::Now ().GetDays () << "|"
            << "Node:" << Mac8Address::ConvertFrom (src)
            << "|Energy:" << (int)(data.Begin ().ReadU8 ()) << "%" << std::endl;
}

void
SetupApplications ()
{
  RawApplicationHelper rawApplicationHelper;
  ApplicationContainer applicationContainer;
  applicationContainer = rawApplicationHelper.Install (nodeContainer);
  applicationContainer.Start (Seconds (0));
  NodeContainer::Iterator node = nodeContainer.Begin ();
  while (node != nodeContainer.End ())
    {
      Ptr<RawApplication> rawApplication = (*node)->GetApplication (0)->GetObject<RawApplication> ();
      rawApplication->SetPacketReceivedCallback (MakeCallback<void, Address, Buffer>(&PrintReceivedPacket));
      node++;
    }
}

void
SendPacket ()
{
  Ptr<UniformRandomVariable> uniformRandomVariable = CreateObject<UniformRandomVariable> ();
  NodeContainer::Iterator node = nodeContainer.Begin ();
  node++;
  while (node != nodeContainer.End ())
    {
      uint8_t energy = ((*node)->GetObject<EnergySourceContainer> ()->Get (0)->GetEnergyFraction ()) * 100;
      Ptr<RawApplication> rawApplication = (*node)->GetApplication (0)->GetObject<RawApplication> ();
      Buffer dataBuffer;
      dataBuffer.AddAtEnd (sizeof (uint8_t));
      Buffer::Iterator i = dataBuffer.Begin ();
      double time = uniformRandomVariable->GetValue (0, 15);
      i.WriteU8 (energy);
      Simulator::Schedule (Seconds (time), &RawApplication::Send, rawApplication, Mac8Address (0), dataBuffer);
      node++;
    }
  Simulator::Schedule (Hours (2), &SendPacket);
}

void
Run ()
{
  Packet::EnablePrinting ();
  nodeContainer.Create (3);
  SetupPositions ();
  SetupEnergy ();
  SetupCommunications ();
  SetupApplications ();
  SendPacket ();
}

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);
  Run ();
  Simulator::Stop (Days (60));
  Simulator::Run ();
  Simulator::Destroy ();

  return 0;
}





    obj = bld.create_ns3_program('uan-rc-example', ['internet', 'mobility', 'stats', 'applications', 'uan'])
    obj.source = 'uan-rc-example.cc'

    obj = bld.create_ns3_program('uan-raw-example', ['internet', 'mobility', 'stats', 'applications', 'uan'])
    obj.source = 'uan-raw-example.cc'

    obj = bld.create_ns3_program('uan-ipv4-example', ['internet', 'mobility', 'stats', 'applications', 'uan'])
    obj.source = 'uan-ipv4-example.cc'

    obj = bld.create_ns3_program('uan-ipv6-example', ['internet', 'mobility', 'stats', 'applications', 'uan'])
    obj.source = 'uan-ipv6-example.cc'

    obj = bld.create_ns3_program('uan-6lowpan-example', ['internet', 'mobility', 'stats', 'applications', 'uan', 'sixlowpan'])
    obj.source = 'uan-6lowpan-example.cc'

(-)a/src/uan/helper/uan-helper.cc (-1 / +1 lines)

Lines 242-248 UanHelper::Install (Ptr<Node> node, Ptr<UanChannel> channel) const	Link Here

242

  Ptr<UanPhy> phy = m_phy.Create<UanPhy> ();

242

  Ptr<UanPhy> phy = m_phy.Create<UanPhy> ();

243

  Ptr<UanTransducer> trans = m_transducer.Create<UanTransducer> ();

243

  Ptr<UanTransducer> trans = m_transducer.Create<UanTransducer> ();

244

245

  mac->SetAddress (UanAddress::Allocate ());

245

  mac->SetAddress (Mac8Address::Allocate ());

246

  device->SetMac (mac);

246

  device->SetMac (mac);

247

  device->SetPhy (phy);

247

  device->SetPhy (phy);

248

  device->SetTransducer (trans);

248

  device->SetTransducer (trans);

(-)a/src/uan/model/uan-header-common.cc (-19 / +56 lines)

Lines 19-25	Link Here

*/

*/

#include "uan-header-common.h"

#include "uan-header-common.h"

#include "uan-address.h"

#include "ns3/arp-l3-protocol.h"

#include "ns3/ipv6-l3-protocol.h"

#include "ns3/ipv4-l3-protocol.h"

namespace ns3 {

namespace ns3 {

Lines 29-41 UanHeaderCommon::UanHeaderCommon ()	Link Here

UanHeaderCommon::UanHeaderCommon (const UanAddress src, const UanAddress dest, uint8_t type)

UanHeaderCommon::UanHeaderCommon (const Mac8Address src, const Mac8Address dest, uint8_t type, uint8_t protocolNumber)

  : Header (),

  : Header (),

    m_dest (dest),

  m_dest (dest),

    m_src (src),

  m_src (src)

    m_type (type)

  SetProtocolNumber (protocolNumber);

  m_uanProtocolBits.m_type = type;

TypeId

TypeId

Lines 60-71 UanHeaderCommon::~UanHeaderCommon ()	Link Here

void

void

UanHeaderCommon::SetDest (UanAddress dest)

UanHeaderCommon::SetDest (Mac8Address dest)

  m_dest = dest;

  m_dest = dest;

void

void

UanHeaderCommon::SetSrc (UanAddress src)

UanHeaderCommon::SetSrc (Mac8Address src)

  m_src = src;

  m_src = src;

Lines 73-87 UanHeaderCommon::SetSrc (UanAddress src)	Link Here

void

void

UanHeaderCommon::SetType (uint8_t type)

UanHeaderCommon::SetType (uint8_t type)

  m_type = type;

  m_uanProtocolBits.m_type = type;

void

UanHeaderCommon::SetProtocolNumber (uint16_t protocolNumber)

  if(protocolNumber == 0)

    m_uanProtocolBits.m_protocolNumber = 0;

  else if(protocolNumber == Ipv4L3Protocol::PROT_NUMBER)

    m_uanProtocolBits.m_protocolNumber = 1;

  else if(protocolNumber == ArpL3Protocol::PROT_NUMBER)

    m_uanProtocolBits.m_protocolNumber = 2;

  else if(protocolNumber == Ipv6L3Protocol::PROT_NUMBER)

    m_uanProtocolBits.m_protocolNumber = 3;

  else

    NS_ASSERT_MSG (false, "UanHeaderCommon::SetProtocolNumber(): Protocol not supported");

UanAddress

Mac8Address

UanHeaderCommon::GetDest (void) const

UanHeaderCommon::GetDest (void) const

  return m_dest;

  return m_dest;

100

UanAddress

101

Mac8Address

UanHeaderCommon::GetSrc (void) const

102

UanHeaderCommon::GetSrc (void) const

103

  return m_src;

104

  return m_src;

Lines 89-95 UanHeaderCommon::GetSrc (void) const	Link Here

uint8_t

106

uint8_t

UanHeaderCommon::GetType (void) const

107

UanHeaderCommon::GetType (void) const

108

  return m_type;

109

  return m_uanProtocolBits.m_type;

110

111

112

uint16_t

113

UanHeaderCommon::GetProtocolNumber (void) const

114

115

  if(m_uanProtocolBits.m_protocolNumber == 1)

116

    return Ipv4L3Protocol::PROT_NUMBER;

117

  if(m_uanProtocolBits.m_protocolNumber == 2)

118

    return ArpL3Protocol::PROT_NUMBER;

119

  if(m_uanProtocolBits.m_protocolNumber == 3)

120

    return Ipv6L3Protocol::PROT_NUMBER;

121

  return 0;

122

123

// Inherrited methods

124

// Inherrited methods

Lines 103-111 UanHeaderCommon::GetSerializedSize (void) const	Link Here

103

void

132

void

104

UanHeaderCommon::Serialize (Buffer::Iterator start) const

133

UanHeaderCommon::Serialize (Buffer::Iterator start) const

105

134

106

  start.WriteU8 (m_src.GetAsInt ());

135

  uint8_t address = 0;

107

  start.WriteU8 (m_dest.GetAsInt ());

136

  m_src.CopyTo (&address);

108

  start.WriteU8 (m_type);

137

  start.WriteU8 (address);

138

  m_dest.CopyTo (&address);

139

  start.WriteU8 (address);

140

  char tmp = m_uanProtocolBits.m_type;

141

  tmp = tmp << 4;

142

  tmp += m_uanProtocolBits.m_protocolNumber;

143

  start.WriteU8 (tmp);

109

144

110

145

111

uint32_t

146

uint32_t

Lines 113-121 UanHeaderCommon::Deserialize (Buffer::Iterator start)	Link Here

113

148

114

  Buffer::Iterator rbuf = start;

149

  Buffer::Iterator rbuf = start;

115

150

116

  m_src = UanAddress (rbuf.ReadU8 ());

151

  m_src = Mac8Address (rbuf.ReadU8 ());

117

  m_dest = UanAddress (rbuf.ReadU8 ());

152

  m_dest = Mac8Address (rbuf.ReadU8 ());

118

  m_type = rbuf.ReadU8 ();

153

  char tmp = rbuf.ReadU8 ();

154

  m_uanProtocolBits.m_type = tmp >> 4;

155

  m_uanProtocolBits.m_protocolNumber = tmp;

119

156

120

  return rbuf.GetDistanceFrom (start);

157

  return rbuf.GetDistanceFrom (start);

121

158

Lines 123-129 UanHeaderCommon::Deserialize (Buffer::Iterator start)	Link Here

123

void

160

void

124

UanHeaderCommon::Print (std::ostream &os) const

161

UanHeaderCommon::Print (std::ostream &os) const

125

162

126

  os << "UAN src=" << m_src << " dest=" << m_dest << " type=" << (uint32_t) m_type;

163

  os << "UAN src=" << m_src << " dest=" << m_dest << " type=" << (uint32_t) m_uanProtocolBits.m_type << "Protocol Number=" << (uint32_t) m_uanProtocolBits.m_protocolNumber;

127

164

128

165

129

166




#include "ns3/header.h"
#include "ns3/nstime.h"
#include "ns3/simulator.h"
#include "ns3/mac8-address.h"

namespace ns3 {

struct UanProtocolBits
{
  uint8_t  m_type : 4;
  uint8_t  m_protocolNumber : 4;
};

/**
 * \ingroup uan
 *
 * Common packet header fields.
 *
 *  1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 * |    src addr   |    dst addr   | prtcl |  type |
 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *
 *
 * src addr: The MAC8 source address
 *
 * dst addr: The MAC8 destination address
 *
 * prtcl: The layer 3 protocol
 * prtcl=1 (IPv4)
 * prtcl=2 (ARP)
 * prtcl=3 (IPv6)
 *
 * type: The type field is MAC protocol specific
 */
class UanHeaderCommon : public Header
{

   * \param src Source address defined in header.
   * \param dest Destination address defined in header.
   * \param type Header type.
   * \param protocolNumber the layer 3 protocol number
   */
  UanHeaderCommon (const Mac8Address src, const Mac8Address dest, uint8_t type, uint8_t protocolNumber);
  /** Destructor */
  virtual ~UanHeaderCommon ();


   *
   * \param dest Address of destination node.
   */
  void SetDest (Mac8Address dest);
  /**
   * Set the source address.
   *
   * \param src Address of packet source node.
   */
  void SetSrc (Mac8Address src);
  /**
   * Set the header type.
   *

   * \param type The type value.
   */
  void SetType (uint8_t type);
  /**
   * Set the packet type.
   *
   * Used to indicate the layer 3 protocol
   * \param protocolNumber The layer 3 protocol number value.
   */
  void SetProtocolNumber (uint16_t protocolNumber);

  /**
   * Get the destination address.
   *
   * \return Mac8Address in destination field.
   */
  Mac8Address GetDest (void) const;
  /**
   * Get the source address
   *
   * \return Mac8Address in source field.
   */
  Mac8Address GetSrc (void) const;
  /**
   * Get the header type value.
   *
   * \return value of type field.
   */
  uint8_t GetType (void) const;
  /**
   * Get the packet type value.
   *
   * \return value of protocolNumber field.
   */
  uint16_t GetProtocolNumber (void) const;

  // Inherited methods
  virtual uint32_t GetSerializedSize (void) const;

  virtual void Print (std::ostream &os) const;
  virtual TypeId GetInstanceTypeId (void) const;
private:
  Mac8Address m_dest;  //!< The destination address.
  Mac8Address m_src;   //!< The source address.
  UanProtocolBits m_uanProtocolBits;  //!< The type and protocol bits

};  // class UanHeaderCommon







#include "uan-header-rc.h"
#include "ns3/mac8-address.h"

#include <set>


    m_timeStampRts (Seconds (0)),
    m_retryNo (0),
    m_delay (Seconds (0)),
    m_address (Mac8Address::GetBroadcast ())
{

}

UanHeaderRcCts::UanHeaderRcCts (uint8_t frameNo, uint8_t retryNo, Time ts, Time delay, Mac8Address addr)
  : Header (),
    m_frameNo (frameNo),
    m_timeStampRts (ts),

}

void
UanHeaderRcCts::SetAddress (Mac8Address addr)
{
  m_address = addr;
}

  return m_retryNo;
}

Mac8Address
UanHeaderRcCts::GetAddress () const
{
  return m_address;

void
UanHeaderRcCts::Serialize (Buffer::Iterator start) const
{
  uint8_t address = 0;
  m_address.CopyTo (&address);
  start.WriteU8 (address);
  start.WriteU8 (m_frameNo);
  start.WriteU8 (m_retryNo);
  start.WriteU32 ((uint32_t)(m_timeStampRts.GetSeconds () * 1000.0 + 0.5));

UanHeaderRcCts::Deserialize (Buffer::Iterator start)
{
  Buffer::Iterator rbuf = start;
  m_address = Mac8Address (rbuf.ReadU8 ());
  m_frameNo = rbuf.ReadU8 ();
  m_retryNo = rbuf.ReadU8 ();
  m_timeStampRts = Seconds ( ( (double) rbuf.ReadU32 ()) / 1000.0 );





#include "ns3/header.h"
#include "ns3/nstime.h"
#include "ns3/mac8-address.h"

#include <set>


   * \param addr Destination of CTS packet.
   * \note Times are serialized, with ms precission, into 32 bit fields.
   */
  UanHeaderRcCts (uint8_t frameNo, uint8_t retryNo, Time rtsTs, Time delay, Mac8Address addr);
  /** Destructor */
  virtual ~UanHeaderRcCts ();


   *
   * \param addr The destination address.
   */
  void SetAddress (Mac8Address addr);

  /**
   * Get the frame number of the RTS being cleared.

   *
   * \return The destination address.
   */
  Mac8Address GetAddress (void) const;

  // Inherrited methods
  virtual uint32_t GetSerializedSize (void) const;

  Time m_timeStampRts;   //!< RX time of RTS packet at gateway.
  uint8_t m_retryNo;     //!< Retry number of received RTS packet.
  Time m_delay;          //!< Delay until transmission.
  Mac8Address m_address;  //!< Destination of CTS packet.

};  // class UanHeaderRcCts






#include "uan-mac-aloha.h"
#include "uan-tx-mode.h"
#include "uan-address.h"
#include "ns3/log.h"
#include "uan-phy.h"
#include "uan-header-common.h"

  return tid;
}

Address
UanMacAloha::GetAddress (void)
{
  return m_address;
}

void
UanMacAloha::SetAddress (UanAddress addr)
{
  m_address=addr;
}
bool
UanMacAloha::Enqueue (Ptr<Packet> packet, uint16_t protocolNumber, const Address &dest)
{
  NS_LOG_DEBUG ("" << Simulator::Now ().GetSeconds () << " MAC " << Mac8Address::ConvertFrom (GetAddress ()) << " Queueing packet for " << Mac8Address::ConvertFrom (dest));

  if (!m_phy->IsStateTx ())
    {
      Mac8Address src = Mac8Address::ConvertFrom (GetAddress ());
      Mac8Address udest = Mac8Address::ConvertFrom (dest);

      UanHeaderCommon header;
      header.SetSrc (src);
      header.SetDest (udest);
      header.SetType (0);
      header.SetProtocolNumber (protocolNumber);

      packet->AddHeader (header);
      m_phy->SendPacket (packet, GetTxModeIndex ());
      return true;
    }
  else

}

void
UanMacAloha::SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb)
{
  m_forUpCb = cb;
}

  pkt->RemoveHeader (header);
  NS_LOG_DEBUG ("Receiving packet from " << header.GetSrc () << " For " << header.GetDest ());

  if (header.GetDest () == GetAddress () || header.GetDest () == Mac8Address::GetBroadcast ())
    {
      m_forUpCb (pkt, header.GetProtocolNumber (), header.GetSrc ());
    }

}

void
UanMacAloha::RxPacketError (Ptr<Packet> pkt, double sinr)
{
  NS_LOG_DEBUG ("" << Simulator::Now () << " MAC " << Mac8Address::ConvertFrom (GetAddress ()) << " Received packet in error with sinr " << sinr);
}

Address
UanMacAloha::GetBroadcast (void) const
{
  UanAddress broadcast (255);
  return broadcast;
}

int64_t




#define UAN_MAC_ALOHA_H

#include "uan-mac.h"
#include "ns3/mac8-address.h"

namespace ns3
{



  // Inherited methods
  virtual bool Enqueue (Ptr<Packet> pkt, uint16_t protocolNumber, const Address &dest);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb);
  virtual bool Enqueue (Ptr<Packet> pkt, const Address &dest, uint16_t protocolNumber);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, const UanAddress& > cb);
  virtual void AttachPhy (Ptr<UanPhy> phy);
  virtual Address GetBroadcast (void) const;
  virtual void Clear (void);
  int64_t AssignStreams (int64_t stream);

private:
  /** The MAC address. */
  Mac8Address m_address;
  /** PHY layer attached to this MAC. */
  Ptr<UanPhy> m_phy;
  /** Forwarding up callback. */
  Callback<void, Ptr<Packet>, uint16_t, const Mac8Address& > m_forUpCb;
  /** Flag when we've been cleared. */
  bool m_cleared;





  return tid;
}

Address
UanMacCw::GetAddress ()
{
  return this->m_address;
}

void
UanMacCw::SetAddress (UanAddress addr)
{
  m_address = addr;
}

bool
UanMacCw::Enqueue (Ptr<Packet> packet, uint16_t protocolNumber, const Address &dest)
{

  switch (m_state)

        NS_ASSERT (!m_pktTx);

        UanHeaderCommon header;
        header.SetDest (Mac8Address::ConvertFrom (dest));
        header.SetSrc (m_address);
        header.SetType (0);
        packet->AddHeader (header);

        m_enqueueLogger (packet, GetTxModeIndex ());

        if (m_phy->IsStateBusy ())
          {
            m_pktTx = packet;
            m_pktTxProt = GetTxModeIndex ();
            m_state = CCABUSY;
            uint32_t cw = (uint32_t) m_rv->GetValue (0,m_cw);
            m_savedDelayS = Seconds ((double)(cw) * m_slotTime.GetSeconds ());

            NS_LOG_DEBUG ("Time " << Simulator::Now ().GetSeconds () << ": Addr " << GetAddress () << ": Enqueuing new packet while idle (sending)");
            NS_ASSERT (m_phy->GetTransducer ()->GetArrivalList ().size () == 0 && !m_phy->IsStateTx ());
            m_state = TX;
            m_phy->SendPacket (packet,GetTxModeIndex ());

          }
        break;

}

void
UanMacCw::SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb)
{
  m_forwardUpCb = cb;
}

  m_phy->RegisterListener (this);
}

Address
UanMacCw::GetBroadcast (void) const
{
  return UanAddress::GetBroadcast ();
}


void
UanMacCw::NotifyRxStart (void)
{

  UanHeaderCommon header;
  packet->RemoveHeader (header);

  if (header.GetDest () == m_address || header.GetDest () == Mac8Address::GetBroadcast ())
    {
      m_forwardUpCb (packet, header.GetProtocolNumber (), header.GetSrc ());
    }
}
void




#include "ns3/simulator.h"
#include "ns3/uan-phy.h"
#include "ns3/uan-tx-mode.h"
#include "ns3/mac8-address.h"
#include "ns3/random-variable-stream.h"

namespace ns3 {

  virtual Time GetSlotTime (void);

  // Inherited methods from UanMac
  virtual bool Enqueue (Ptr<Packet> pkt, uint16_t protocolNumber, const Address &dest);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb);
  virtual bool Enqueue (Ptr<Packet> pkt, const Address &dest, uint16_t protocolNumber);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, const UanAddress&> cb);
  virtual void AttachPhy (Ptr<UanPhy> phy);
  virtual Address GetBroadcast (void) const;
  virtual void Clear (void);
  int64_t AssignStreams (int64_t stream);


  } State;

  /** Forwarding up callback. */
  Callback <void, Ptr<Packet>, uint16_t, const Mac8Address&> m_forwardUpCb;
  /** The MAC address. */
  Mac8Address m_address;
  /** PHY layer attached to this MAC. */
  Ptr<UanPhy> m_phy;
  /** A packet destined for this MAC was received. */




      m_phy = 0;
    }
  m_propDelay.clear ();
  std::map<Mac8Address, AckData>::iterator it = m_ackData.begin ();
  for (; it != m_ackData.end (); it++)
    {
      it->second.rxFrames.clear ();

  return tid;
}

Address
UanMacRcGw::GetAddress (void)
{
  return m_address;
}

void
UanMacRcGw::SetAddress (UanAddress addr)
{
  m_address = addr;
}

bool
UanMacRcGw::Enqueue (Ptr<Packet> packet, uint16_t protocolNumber, const Address &dest)
{
  NS_LOG_WARN ("RCMAC Gateway transmission to acoustic nodes is not yet implemented");
  return false;
}

void
UanMacRcGw::SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb)
{
  m_forwardUpCb = cb;
}

{
}

Address
UanMacRcGw::GetBroadcast (void) const
{
  return UanAddress::GetBroadcast ();
}

void
UanMacRcGw::ReceivePacket (Ptr<Packet> pkt, double sinr, UanTxMode mode)
{
  UanHeaderCommon ch;
  pkt->PeekHeader (ch);

  if (ch.GetDest () == m_address || ch.GetDest () == Mac8Address::GetBroadcast ())
    {
      m_rxLogger (pkt, mode);
    }

            NS_LOG_DEBUG (Simulator::Now ().GetSeconds () << " GW Received data packet from " << ch.GetSrc () << " length = " << pkt->GetSize ());
            m_ackData[ch.GetSrc ()].rxFrames.insert (dh.GetFrameNo ());
          }
        m_forwardUpCb (pkt, ch.GetProtocolNumber (), ch.GetSrc ());
      }
      break;
    case UanMacRc::TYPE_GWPING:

            req.length = rh.GetLength ();
            NS_LOG_DEBUG (Simulator::Now ().GetSeconds () << " GW storing reservation from " << ch.GetSrc () << " with length " << req.length);
            m_requests.insert (std::make_pair (ch.GetSrc (), req));
            std::map<Mac8Address, Time>::iterator it = m_propDelay.find (ch.GetSrc ());
            if (it == m_propDelay.end ())
              {
                m_sortedRes.insert (std::make_pair (m_maxDelta, ch.GetSrc ()));

  double pDelay = 0;
  if (numRts > 0)
    {
      std::map<Mac8Address, Request>::iterator rit = m_requests.begin ();
      for (; rit != m_requests.end (); rit++)
        {
          totalBytes += (*rit).second.length;

      ctsg.SetRetryRate (m_currentRetryRate);
      ctsg.SetTxTimeStamp (Simulator::Now ());

      UanHeaderCommon ch (m_address, Mac8Address::GetBroadcast (), UanMacRc::TYPE_CTS, 0);
      Ptr<Packet> p = Create<Packet> ();
      p->AddHeader (ctsg);
      p->AddHeader (ch);

  m_state = CTSING;
  Simulator::Schedule (nextEarliest, &UanMacRcGw::CycleStarted, this);

  std::set<std::pair<Time, Mac8Address> >::iterator it = m_sortedRes.begin ();
  Time minPdelay = (*it).first;
  Ptr<Packet> cts = Create<Packet> ();


      AckData newData;
      newData.expFrames = req.numFrames;
      newData.frameNo = req.frameNo;
      Mac8Address dest = (*it).second;
      m_ackData.insert (std::make_pair (dest, newData));

      Time earliestArr = ctsTxTimeTotal + pdelay + pdelay + m_sifs;

  ctsg.SetWindowTime (Seconds (effWinSize));
  ctsg.SetTxTimeStamp (Simulator::Now ());
  UanHeaderCommon ch;
  ch.SetDest (Mac8Address::GetBroadcast ());
  ch.SetSrc (m_address);
  ch.SetType (UanMacRc::TYPE_CTS);
  cts->AddHeader (ctsg);


  Time ackTime = Seconds (m_ackSize * 8.0 / m_phy->GetMode (m_currentRateNum).GetDataRateBps ());

  std::map<Mac8Address, AckData>::iterator it = m_ackData.begin ();
  for (; it != m_ackData.end (); it++)
    {
      Mac8Address dest = (*it).first;
      AckData &data = (*it).second;

      std::list<uint32_t> toNack;

{
  uint32_t n = m_numNodes;
  std::vector<double> pds;
  std::map<Mac8Address, Time>::iterator pdit = m_propDelay.begin ();

  for (; pdit != m_propDelay.end (); pdit++)
    {




#define UAN_MAC_RC_GW_H

#include "uan-mac.h"
#include "ns3/mac8-address.h"

#include "ns3/nstime.h"
#include "ns3/traced-callback.h"

  static TypeId GetTypeId (void);

  // Inherited methods
  virtual bool Enqueue (Ptr<Packet> pkt, uint16_t protocolNumber, const Address &dest);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb);
  virtual bool Enqueue (Ptr<Packet> pkt, const Address &dest, uint16_t protocolNumber);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, const UanAddress&> cb);
  virtual void AttachPhy (Ptr<UanPhy> phy);
  virtual Address GetBroadcast (void) const;
  virtual void Clear (void);
  int64_t AssignStreams (int64_t stream);


    uint8_t expFrames;  //!< Expected number of frames.
  };
  /** Forwarding up callback. */
  Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> m_forwardUpCb;
  
  Ptr<UanPhy> m_phy;            //!< PHY layer attached to this MAC.
  Mac8Address m_address;         //!< The MAC address.
  Time m_maxDelta;              //!< Maximum propagation delay between gateway and non-gateway nodes .
  Time m_sifs;                  //!< Spacing between frames to account for timing error and processing delay.
  uint32_t m_maxRes;            //!< Maximum number of reservations to accept per cycle.

  double m_retryStep;           //!< Retry rate increment.

  /** Propagation delay to each node. */
  std::map<Mac8Address, Time> m_propDelay;

  /** AckData for each node. */
  std::map<Mac8Address, AckData> m_ackData;

  /** Request for each node. */
  std::map<Mac8Address, Request> m_requests;
  /** Queued request times. */
  std::set<std::pair<Time, Mac8Address> > m_sortedRes;

  /** Flag when we've been cleared. */
  bool m_cleared;





}

Reservation::Reservation (std::list<std::pair <Ptr<Packet>, Mac8Address > > &list, uint8_t frameNo, uint32_t maxPkts)
  : m_frameNo (frameNo),
    m_retryNo (0),
    m_transmitted (false)


Reservation::~Reservation ()
{
  std::list<std::pair <Ptr<Packet>, Mac8Address > >::iterator it;
  for (it = m_pktList.begin (); it != m_pktList.end (); it++)
    {
      it->first = Ptr<Packet> ((Packet *) 0);

  return m_length;
}

const std::list<std::pair <Ptr<Packet>, Mac8Address > > &
Reservation::GetPktList (void) const
{
  return m_pktList;

      m_phy->Clear ();
      m_phy = 0;
    }
  std::list<std::pair <Ptr<Packet>, Mac8Address > >::iterator it;
  for (it = m_pktQueue.begin (); it != m_pktQueue.end (); it++)
    {
      it->first = 0;

  return 1;
}

Address
UanMacRc::GetAddress (void)
{
  return m_address;
}

void
UanMacRc::SetAddress (UanAddress addr)
{
  m_address = addr;
}

bool
UanMacRc::Enqueue (Ptr<Packet> packet, uint16_t protocolNumber, const Address &dest)
{
  if (protocolNumber > 0)
    {

      return false;
    }

  m_pktQueue.push_back (std::make_pair (packet, Mac8Address::ConvertFrom (dest)));

  switch (m_state)
    {

}

void
UanMacRc::SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb)
{
  m_forwardUpCb = cb;
}

  m_phy->SetReceiveOkCallback (MakeCallback (&UanMacRc::ReceiveOkFromPhy, this));
}

Address
UanMacRc::GetBroadcast (void) const
{
  return UanAddress::GetBroadcast ();
}

void
UanMacRc::ReceiveOkFromPhy (Ptr<Packet> pkt, double sinr, UanTxMode mode)
{

  UanHeaderCommon ch;
  pkt->RemoveHeader (ch);
  if (ch.GetDest () == m_address || ch.GetDest () == Mac8Address::GetBroadcast ())
    {
      m_rxLogger (pkt, mode);
    }

          NS_LOG_DEBUG (Simulator::Now ().GetSeconds () << " Node " << m_address << " UanMacRc Receiving DATA packet from PHY");
          UanHeaderRcData dh;
          pkt->RemoveHeader (dh);
          m_forwardUpCb (pkt, ch.GetProtocolNumber (), ch.GetSrc ());
        }
      break;
    case TYPE_RTS:

          }

        UanHeaderRcCts ctsh;
        ctsh.SetAddress (Mac8Address::GetBroadcast ());
        while (pkt->GetSize () > 0)
          {
            pkt->RemoveHeader (ctsh);


  Time frameDelay = Seconds (0);

  const std::list<std::pair <Ptr<Packet>, Mac8Address > > l = it->GetPktList ();
  std::list<std::pair <Ptr<Packet>, Mac8Address > >::const_iterator pit;
  pit = l.begin ();



    }
  if (ah.GetNoNacks () > 0)
    {
      const std::list<std::pair <Ptr<Packet>, Mac8Address > > l = it->GetPktList ();
      std::list<std::pair <Ptr<Packet>, Mac8Address > >::const_iterator pit;
      pit = l.begin ();

      const std::set<uint8_t> &nacks = ah.GetNackedFrames ();

    {
      Ptr<Packet> pkt = Create<Packet> (0);
      pkt->AddHeader (CreateRtsHeader (res));
      pkt->AddHeader (UanHeaderCommon (m_address, Mac8Address::GetBroadcast (), static_cast<uint8_t>(TYPE_GWPING), 0));
      NS_LOG_DEBUG (Simulator::Now ().GetSeconds () << " Sending first GWPING " << *pkt);
      SendPacket (pkt,m_currentRate + m_numRates);
    }

      res.IncrementRetry ();

      pkt->AddHeader (CreateRtsHeader (res));
      pkt->AddHeader (UanHeaderCommon (m_address, Mac8Address::GetBroadcast (), static_cast<uint8_t> (TYPE_GWPING), 0));

      SendPacket (pkt,m_currentRate + m_numRates);
      m_resList.push_back (res);

    {
      Ptr<Packet> pkt = Create<Packet> (0);
      pkt->AddHeader (CreateRtsHeader (res));
      pkt->AddHeader (UanHeaderCommon (m_address, Mac8Address::GetBroadcast (), static_cast<uint8_t> (TYPE_RTS), 0));
      SendPacket (pkt,m_currentRate + m_numRates);
    }
  m_state = RTSSENT;

      res.IncrementRetry ();
      m_resList.push_back (res);
      pkt->AddHeader (CreateRtsHeader (res));
      pkt->AddHeader (UanHeaderCommon (m_address, Mac8Address::GetBroadcast (), static_cast<uint8_t> (TYPE_RTS), 0));
      SendPacket (pkt,m_currentRate + m_numRates);

    }




#define UAN_MAC_RC_H

#include "uan-mac.h"
#include "ns3/mac8-address.h"

#include "ns3/nstime.h"
#include "ns3/trace-source-accessor.h"

   * \param maxPkts Maximum number of packets to assign to reservation
   *   from packet list (0 = no maximum).
   */
  Reservation (std::list<std::pair <Ptr<Packet>, Mac8Address > > &list, uint8_t frameNo, uint32_t maxPkts = 0);
  /** Destructor */
  ~Reservation ();
  /**

   *
   * \return The list of packets.
   */
  const std::list<std::pair <Ptr<Packet>, Mac8Address > > &GetPktList (void) const;
  /**
   * Get the frame number.
   * 


private:
  /** Queued packets for each address. */
  std::list<std::pair <Ptr<Packet>, Mac8Address > > m_pktList;
  /** Total length of queued packets. */
  uint32_t m_length;
  /** Frame number. */

  static TypeId GetTypeId (void);

  // Inherited methods
  virtual bool Enqueue (Ptr<Packet> pkt, uint16_t protocolNumber, const Address &dest);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb);
  virtual bool Enqueue (Ptr<Packet> pkt, const Address &dest, uint16_t protocolNumber);
  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, const UanAddress&> cb);
  virtual void AttachPhy (Ptr<UanPhy> phy);
  virtual Address GetBroadcast (void) const;
  virtual void Clear (void);
  int64_t AssignStreams (int64_t stream);


  bool m_rtsBlocked;       //!< RTS blocked while processing ACK.

  EventId m_startAgain;    //!< (Unused).
  Mac8Address m_address;    //!< My addrese.s
  double m_retryRate;      //!< Number of retry attempts per second (of RTS/GWPING.
  Mac8Address m_assocAddr;  //!< Next hop address.
  Ptr<UanPhy> m_phy;       //!< PHY layer attached to this MAC.
  uint32_t m_numRates;     //!< Number of rates per Phy layer.
  uint32_t m_currentRate;  //!< Rate number corresponding to data rate of current cycle.

  bool m_cleared;          //!< Flag when we've been cleared.

  /** Pending packets. */
  std::list<std::pair <Ptr<Packet>, Mac8Address > > m_pktQueue;
  /** List of scheduled reservations. */
  std::list<Reservation> m_resList;

  /** The callback to forward a packet up to higher layer. */
  Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> m_forwardUpCb;

  /** A packet was destined for and received at this MAC layer. */
  TracedCallback<Ptr<const Packet>, UanTxMode > m_rxLogger;

(-)a/src/uan/model/uan-mac.cc (+37 lines)

Lines 24-29 namespace ns3 {	Link Here

NS_OBJECT_ENSURE_REGISTERED (UanMac);

NS_OBJECT_ENSURE_REGISTERED (UanMac);

UanMac::UanMac ()

  : m_txModeIndex (0)

TypeId UanMac::GetTypeId (void)

TypeId UanMac::GetTypeId (void)

  static TypeId tid = TypeId ("ns3::UanMac")

  static TypeId tid = TypeId ("ns3::UanMac")

Lines 33-36 TypeId UanMac::GetTypeId (void)	Link Here

  return tid;

  return tid;

void

UanMac::SetTxModeIndex (uint32_t txModeIndex)

  m_txModeIndex = txModeIndex;

uint32_t

UanMac::GetTxModeIndex ()

  return m_txModeIndex;

Address

UanMac::GetAddress (void)

  return m_address;

void

UanMac::SetAddress (Mac8Address addr)

  m_address=addr;

Address

UanMac::GetBroadcast (void) const

  Mac8Address broadcast = Mac8Address (255);

  return broadcast;

} // namespace ns3

} // namespace ns3

(-)a/src/uan/model/uan-mac.h (-8 / +20 lines)

Lines 28-33	Link Here

#include "ns3/address.h"

#include "ns3/address.h"

#include "ns3/nstime.h"

#include "ns3/nstime.h"

#include "ns3/ptr.h"

#include "ns3/ptr.h"

#include "ns3/mac8-address.h"

namespace ns3 {

namespace ns3 {

Lines 36-42 class UanChannel;	Link Here

class UanNetDevice;

class UanNetDevice;

class UanTransducer;

class UanTransducer;

class UanTxMode;

class UanTxMode;

class UanAddress;

class Mac8Address;

Lines 48-53 class UanAddress;	Link Here

class UanMac : public Object

class UanMac : public Object

public:

public:

  /** Default constructor */

  UanMac ();

/**

/**

   * Register this type.

   * Register this type.

   * \return The TypeId.

   * \return The TypeId.

Lines 59-82 public:	Link Here

   * \return MAC Address.

   * \return MAC Address.

*/

*/

  virtual Address GetAddress (void) = 0;

  virtual Address GetAddress (void);

/**

/**

   * Set the address.

   * Set the address.

   * \param addr UanAddress for this MAC.

   * \param addr Mac8Address for this MAC.

*/

*/

  virtual void SetAddress (UanAddress addr) = 0;

  virtual void SetAddress (Mac8Address addr);

/**

/**

   * Enqueue packet to be transmitted.

   * Enqueue packet to be transmitted.

   * \param pkt Packet to be transmitted.

   * \param pkt Packet to be transmitted.

   * \param dest Destination address.

   * \param dest Destination address.

   * \param protocolNumber Protocol number.  Usage varies by MAC.

   * \param protocolNumber The type of the packet.

   * \return True if packet was successfully enqueued.

   * \return True if packet was successfully enqueued.

*/

*/

  virtual bool Enqueue (Ptr<Packet> pkt, const Address &dest, uint16_t protocolNumber) = 0;

  virtual bool Enqueue (Ptr<Packet> pkt, uint16_t protocolNumber, const Address &dest) = 0;

/**

/**

   * Set the callback to forward packets up to higher layers.

   * Set the callback to forward packets up to higher layers.

Lines 84-90 public:	Link Here

   * \pname{packet} The packet.

   * \pname{packet} The packet.

   * \pname{address} The source address.

   * \pname{address} The source address.

*/

*/

  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, const UanAddress&> cb) = 0;

  virtual void SetForwardUpCb (Callback<void, Ptr<Packet>, uint16_t, const Mac8Address&> cb) = 0;

/**

/**

   * Attach PHY layer to this MAC.

   * Attach PHY layer to this MAC.

Lines 101-107 public:	Link Here

101

104

102

   * \return The broadcast address.

105

   * \return The broadcast address.

103

*/

106

*/

104

  virtual Address GetBroadcast (void) const = 0;

107

  virtual Address GetBroadcast (void) const;

105

108

106

  /** Clears all pointer references. */

109

  /** Clears all pointer references. */

107

  virtual void Clear (void) = 0;

110

  virtual void Clear (void) = 0;

Lines 125-130 public:	Link Here

125

  typedef void (* PacketModeTracedCallback)

128

  typedef void (* PacketModeTracedCallback)

126

    (Ptr<const Packet> packet, UanTxMode mode);

129

    (Ptr<const Packet> packet, UanTxMode mode);

127

130

131

  uint32_t GetTxModeIndex ();

132

  void SetTxModeIndex (uint32_t txModeIndex);

133

134

private:

135

  /** Modulation type */

136

  uint32_t m_txModeIndex;

137

  /** The MAC address. */

138

  Mac8Address m_address;

139

128

};  // class UanMac

140

};  // class UanMac

129

141

130

} // namespace ns3

142

} // namespace ns3




bool
UanNetDevice::IsMulticast () const
{
  return true;
}

Address
UanNetDevice::GetMulticast (Ipv4Address multicastGroup) const
{
  NS_FATAL_ERROR ("UanNetDevice does not support multicast");
  return m_mac->GetBroadcast ();
}

Address
UanNetDevice::GetMulticast (Ipv6Address addr) const
{
  NS_FATAL_ERROR ("UanNetDevice does not support multicast");
  return m_mac->GetBroadcast ();
}


bool
UanNetDevice::Send (Ptr<Packet> packet, const Address &dest, uint16_t protocolNumber)
{
  uint8_t tmp [6];
  dest.CopyTo (tmp);
  Mac8Address udest (tmp[0]);

  return m_mac->Enqueue (packet, protocolNumber, udest);
}

bool

bool
UanNetDevice::NeedsArp () const
{
  return true;
}

void

}

void
UanNetDevice::ForwardUp (Ptr<Packet> pkt, uint16_t protocolNumber, const Mac8Address &src)
{
  NS_LOG_DEBUG ("Forwarding packet up to application");
  m_rxLogger (pkt, src);
  m_forwardUp (this, pkt, protocolNumber, src);

}


UanNetDevice::SetAddress (Address address)
{
  NS_ASSERT_MSG (0, "Tried to set MAC address with no MAC");
  m_mac->SetAddress (Mac8Address::ConvertFrom (address));
}

void

  m_phy->SetSleepMode (sleep);
}

void
UanNetDevice::SetTxModeIndex (uint32_t txModeIndex)
{
  m_mac->SetTxModeIndex (txModeIndex);
}

uint32_t
UanNetDevice::GetTxModeIndex ()
{
  return m_mac->GetTxModeIndex ();
}

} // namespace ns3


(-)a/src/uan/model/uan-net-device.h (-5 / +8 lines)

Lines 24-30	Link Here

#include "ns3/net-device.h"

#include "ns3/net-device.h"

#include "ns3/pointer.h"

#include "ns3/pointer.h"

#include "ns3/traced-callback.h"

#include "ns3/traced-callback.h"

#include "uan-address.h"

#include "ns3/mac8-address.h"

#include <list>

#include <list>

namespace ns3 {

namespace ns3 {

Lines 146-151 public:	Link Here

146

  virtual bool SupportsSendFrom (void) const;

146

  virtual bool SupportsSendFrom (void) const;

147

  virtual void AddLinkChangeCallback (Callback<void> callback);

147

  virtual void AddLinkChangeCallback (Callback<void> callback);

148

  virtual void SetAddress (Address address);

148

  virtual void SetAddress (Address address);

149

  uint32_t GetTxModeIndex ();

150

  void SetTxModeIndex (uint32_t txModeIndex);

149

151

150

/**

152

/**

151

   * TracedCallback signature for MAC send/receive events.

153

   * TracedCallback signature for MAC send/receive events.

Lines 154-160 public:	Link Here

154

   * \param [in] address The source address.

156

   * \param [in] address The source address.

155

*/

157

*/

156

  typedef void (* RxTxTracedCallback)

158

  typedef void (* RxTxTracedCallback)

157

    (Ptr<const Packet> packet, UanAddress address);

159

    (Ptr<const Packet> packet, Mac8Address address);

158

160

159

private:

161

private:

160

/**

162

/**

Lines 162-169 private:	Link Here

162

164

163

   * \param pkt The packet.

165

   * \param pkt The packet.

164

   * \param src The source address.

166

   * \param src The source address.

167

   * \param protocolNumber The layer 3 protocol number.

165

*/

168

*/

166

  virtual void ForwardUp (Ptr<Packet> pkt, const UanAddress &src);

169

  virtual void ForwardUp (Ptr<Packet> pkt, uint16_t protocolNumber, const Mac8Address &src);

167

170

168

  /** \return The channel attached to this device. */

171

  /** \return The channel attached to this device. */

169

  Ptr<UanChannel> DoGetChannel (void) const;

172

  Ptr<UanChannel> DoGetChannel (void) const;

Lines 182-190 private:	Link Here

182

  ReceiveCallback m_forwardUp;     //!< The receive callback.

185

  ReceiveCallback m_forwardUp;     //!< The receive callback.

183

186

184

  /** Trace source triggered when forwarding up received payload from the MAC layer. */

187

  /** Trace source triggered when forwarding up received payload from the MAC layer. */

185

  TracedCallback<Ptr<const Packet>, UanAddress> m_rxLogger;

188

  TracedCallback<Ptr<const Packet>, Mac8Address> m_rxLogger;

186

  /** Trace source triggered when sending to the MAC layer */

189

  /** Trace source triggered when sending to the MAC layer */

187

  TracedCallback<Ptr<const Packet>, UanAddress> m_txLogger;

190

  TracedCallback<Ptr<const Packet>, Mac8Address> m_txLogger;

188

191

189

  /** Flag when we've been cleared. */

192

  /** Flag when we've been cleared. */

190

  bool m_cleared;

193

  bool m_cleared;

(-)a/src/uan/test/uan-test.cc (-2 / +3 lines)

Lines 107-113 void	Link Here

107

UanTest::SendOnePacket (Ptr<UanNetDevice> dev, uint32_t mode)

107

UanTest::SendOnePacket (Ptr<UanNetDevice> dev, uint32_t mode)

108

109

  Ptr<Packet> pkt = Create<Packet> (17);

109

  Ptr<Packet> pkt = Create<Packet> (17);

110

  dev->Send (pkt, dev->GetBroadcast (), mode);

110

  dev->SetTxModeIndex (mode);

111

  dev->Send (pkt, dev->GetBroadcast (), 0);

111

112

113

Ptr<UanNetDevice>

114

Ptr<UanNetDevice>

Lines 125-131 UanTest::CreateNode (Vector pos, Ptr<UanChannel> chan)	Link Here

125

126

  mobility->SetPosition (pos);

127

  mobility->SetPosition (pos);

127

  node->AggregateObject (mobility);

128

  node->AggregateObject (mobility);

128

  mac->SetAddress (UanAddress::Allocate ());

129

  mac->SetAddress (Mac8Address::Allocate ());

129

130

  dev->SetPhy (phy);

131

  dev->SetPhy (phy);

131

  dev->SetMac (mac);

132

  dev->SetMac (mac);

(-)a/src/uan/wscript (-2 lines)

Lines 8-14 def build(bld):	Link Here

        'model/uan-mac.cc',

        'model/uan-mac.cc',

        'model/uan-transducer.cc',

        'model/uan-transducer.cc',

        'model/uan-transducer-hd.cc',

        'model/uan-transducer-hd.cc',

        'model/uan-address.cc',

        'model/uan-net-device.cc',

        'model/uan-net-device.cc',

        'model/uan-tx-mode.cc',

        'model/uan-tx-mode.cc',

        'model/uan-prop-model.cc',

        'model/uan-prop-model.cc',

Lines 46-52 def build(bld):	Link Here

        'model/uan-transducer.h',

        'model/uan-transducer.h',

        'model/uan-phy-gen.h',

        'model/uan-phy-gen.h',

        'model/uan-transducer-hd.h',

        'model/uan-transducer-hd.h',

        'model/uan-address.h',

        'model/uan-prop-model-ideal.h',

        'model/uan-prop-model-ideal.h',

        'model/uan-mac-aloha.h',

        'model/uan-mac-aloha.h',

        'model/uan-header-common.h',

        'model/uan-header-common.h',

Return to bug 2882