Attachment #136 for bug #187

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

(-)a/examples/csma-one-subnet.cc (+1 lines)

Lines 80-85 main (int argc, char *argv[])	Link Here

  NetDeviceContainer nd0 = csma.Install (c);

  NetDeviceContainer nd0 = csma.Install (c);

  InternetStackHelper internet;

  InternetStackHelper internet;

  internet.UseGodArp ();

  internet.Install (c);

  internet.Install (c);

// We've got the "hardware" in place.  Now we need to add IP addresses.

// We've got the "hardware" in place.  Now we need to add IP addresses.




  m_traces.clear ();
}

InternetStackHelper::InternetStackHelper ()
  : m_godArp (false)
{}

void 
InternetStackHelper::UseGodArp (void)
{
  m_godArp = true;
}
void 
InternetStackHelper::UseRealArp (void)
{
  m_godArp = false;
}


void 
InternetStackHelper::Install (NodeContainer c)
{

          NS_FATAL_ERROR ("InternetStackHelper::Install(): Aggregating " 
             "an InternetStack to a node with an existing Ipv4 object");
          return;
        }
      if (m_godArp)
        {
          InternetStack::AddGodArp (node);
        }
      else
        {
          InternetStack::AddRealArp (node);
        }
      InternetStack::AddIpv4 (node);
      InternetStack::AddUdp (node);
      InternetStack::AddTcp (node);

      Ptr<PacketSocketFactory> factory = CreateObject<PacketSocketFactory> ();
      node->AggregateObject (factory);
    }




class InternetStackHelper
{
public:
  InternetStackHelper ();
  /**
   * Every internet stack created with Install after calling this 
   * method will contain a 'God' ARP implementation.
   *
   * \sa ns3::GodArp
   */
  void UseGodArp (void);
  /*
   * Every internet stack created with Install after calling this 
   * method will contain a 'Real' ARP implementation.
   *
   * \sa ns3::Ipv4L3Protocol
   */
  void UseRealArp (void);

  /**
   * \param c the set of nodes
   *

  static std::string m_pcapBaseFilename;
  static uint32_t GetNodeIndex (std::string context);
  static std::vector<Trace> m_traces;
  bool m_godArp;
};

} // namespace ns3

(-)a/src/internet-node/arp-ipv4-interface.cc (-2 / +2 lines)

Lines 76-83 ArpIpv4Interface::SendTo (Ptr<Packet> p,	Link Here

  if (GetDevice ()->NeedsArp ())

  if (GetDevice ()->NeedsArp ())

      NS_LOG_LOGIC ("Needs ARP");

      NS_LOG_LOGIC ("Needs ARP");

      Ptr<ArpL3Protocol> arp =

      Ptr<Arp> arp =

        m_node->GetObject<ArpL3Protocol> ();

        m_node->GetObject<Arp> ();

      Address hardwareDestination;

      Address hardwareDestination;

      bool found;

      bool found;

(-)a/src/internet-node/arp-l3-protocol.cc (-1 / +1 lines)

Lines 40-46 ArpL3Protocol::GetTypeId (void)	Link Here

ArpL3Protocol::GetTypeId (void)

ArpL3Protocol::GetTypeId (void)

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

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

    .SetParent<Object> ()

    .SetParent<Arp> ()

  return tid;

  return tid;




#define ARP_L3_PROTOCOL_H

#include <list>
#include "arp.h"
#include "ns3/ipv4-address.h"
#include "ns3/address.h"
#include "ns3/ptr.h"

/**
 * \brief An implementation of the ARP protocol
 */
class ArpL3Protocol : public Arp
{
public:
  static TypeId GetTypeId (void);

   * \brief Recieve a packet
   */
  void Receive(Ptr<NetDevice> device, Ptr<Packet> p, uint16_t protocol, const Address &from);

  virtual bool Lookup (Ptr<Packet> p, Ipv4Address destination, 
                       Ptr<NetDevice> device,
                       Address *hardwareDestination);
   * \param device
   * \param hardwareDestination
   * \return 
   */
  bool Lookup (Ptr<Packet> p, Ipv4Address destination, 
	       Ptr<NetDevice> device,
	       Address *hardwareDestination);
protected:
  virtual void DoDispose (void);
private:




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2006 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#include "arp.h"

namespace ns3 {

TypeId 
Arp::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::Arp")
    .SetParent<Object> ()
    ;
  return tid;
}

Arp::~Arp ()
{}

} // namespace ns3




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2006 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef ARP_H
#define ARP_H

#include <list>
#include "ns3/object.h"
#include "ns3/ipv4-address.h"
#include "ns3/ptr.h"

namespace ns3 {

class NetDevice;
class Node;
class Packet;
class Address;

/**
 * \brief An interface to access the functionality provided
 *        by the ARP layer.
 */
class Arp : public Object
{
public:
  static TypeId GetTypeId (void);

  virtual ~Arp ();

  /**
   * \brief Perform an ARP lookup
   * \param p
   * \param destination
   * \param device
   * \param hardwareDestination
   * \return 
   */
  virtual bool Lookup (Ptr<Packet> p, Ipv4Address destination, 
                       Ptr<NetDevice> device,
                       Address *hardwareDestination) = 0;
};

}//namespace ns3


#endif /* ARP_H */




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#include "god-arp.h"
#include "ns3/ipv4.h"
#include "ns3/channel.h"
#include "ns3/net-device.h"
#include "ns3/node.h"

namespace ns3 {

TypeId 
GodArp::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::GodArp")
    .SetParent<Arp> ()
    ;
  return tid;
}

GodArp::GodArp ()
{}
  
bool 
GodArp::Lookup (Ptr<Packet> p, Ipv4Address destination, 
		Ptr<NetDevice> device,
		Address *hardwareDestination)
{
  Ptr<Channel> channel = device->GetChannel ();
  for (uint32_t i = 0; i < channel->GetNDevices (); ++i)
    {
      Ptr<NetDevice> remote = channel->GetDevice (i);
      Ptr<Node> remoteNode = remote->GetNode ();
      Ptr<Ipv4> remoteIpv4 = remoteNode->GetObject<Ipv4> ();
      if (remoteIpv4 == 0)
	{
	  continue;
	}
      int32_t index = remoteIpv4->FindInterfaceForDevice (remote);
      if (index == -1)
	{
	  continue;
	}
      *hardwareDestination = remote->GetAddress ();
      return true;
    }
  return false;
}

} // namespace ns3 




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef GOD_ARP_H
#define GOD_ARP_H

#include "arp.h"

namespace ns3 {

class GodArp : public Arp
{
public:
  static TypeId GetTypeId (void);
  GodArp ();
  
  virtual bool Lookup (Ptr<Packet> p, Ipv4Address destination, 
                       Ptr<NetDevice> device,
                       Address *hardwareDestination);
};


} // namespace ns3

#endif /* GOD_ARP_H */




#include "tcp-l4-protocol.h"
#include "ipv4-l3-protocol.h"
#include "arp-l3-protocol.h"
#include "god-arp.h"
#include "udp-impl.h"
#include "tcp-impl.h"
#include "ipv4-impl.h"

namespace ns3 {

namespace InternetStack {

static Ptr<Ipv4L4Demux>
AddIpv4L4Demux (Ptr<Node> node)
{

  Ptr<Ipv4L4Demux> ipv4L4Demux = node->GetObject<Ipv4L4Demux> ();
  if (ipv4L4Demux != 0)
    {
      return ipv4L4Demux;
    }
  ipv4L4Demux = CreateObject<Ipv4L4Demux> ();
  ipv4L4Demux->SetNode (node);
  node->AggregateObject (ipv4L4Demux);
  return ipv4L4Demux;
}

void
AddTcp (Ptr<Node> node)
{
  Ptr<TcpL4Protocol> tcp = CreateObject<TcpL4Protocol> ();
  tcp->SetNode (node);
  Ptr<Ipv4L4Demux> ipv4L4Demux = AddIpv4L4Demux (node);
  ipv4L4Demux->Insert (tcp);
  Ptr<TcpImpl> tcpImpl = CreateObject<TcpImpl> ();
  tcpImpl->SetTcp (tcp);
  node->AggregateObject (tcpImpl);
}

void
AddUdp (Ptr<Node> node)
{
  Ptr<UdpL4Protocol> udp = CreateObject<UdpL4Protocol> ();
  udp->SetNode (node);
  Ptr<Ipv4L4Demux> ipv4L4Demux = AddIpv4L4Demux (node);
  ipv4L4Demux->Insert (udp);
  Ptr<UdpImpl> udpImpl = CreateObject<UdpImpl> ();
  udpImpl->SetUdp (udp);
  node->AggregateObject (udpImpl);
}

void 
AddIpv4 (Ptr<Node> node)
{
  Ptr<Ipv4L3Protocol> ipv4 = CreateObject<Ipv4L3Protocol> ();
  Ptr<ArpL3Protocol> arp = CreateObject<ArpL3Protocol> ();
  ipv4->SetNode (node);
  arp->SetNode (node);
  // XXX remove the PeekPointer below.
  node->RegisterProtocolHandler (MakeCallback (&Ipv4L3Protocol::Receive, PeekPointer (ipv4)), 
                                 Ipv4L3Protocol::PROT_NUMBER, 0);
  node->RegisterProtocolHandler (MakeCallback (&ArpL3Protocol::Receive, PeekPointer (arp)),
                                 ArpL3Protocol::PROT_NUMBER, 0);


  Ptr<Ipv4L4Demux> ipv4L4Demux = CreateObject<Ipv4L4Demux> ();
  Ptr<UdpL4Protocol> udp = CreateObject<UdpL4Protocol> ();
  Ptr<TcpL4Protocol> tcp = CreateObject<TcpL4Protocol> ();

  ipv4L4Demux->SetNode (node);
  udp->SetNode (node);
  tcp->SetNode (node);

  ipv4L4Demux->Insert (udp);
  ipv4L4Demux->Insert (tcp);

  Ptr<UdpImpl> udpImpl = CreateObject<UdpImpl> ();
  Ptr<TcpImpl> tcpImpl = CreateObject<TcpImpl> ();
  Ptr<Ipv4Impl> ipv4Impl = CreateObject<Ipv4Impl> ();

  udpImpl->SetUdp (udp);
  tcpImpl->SetTcp (tcp);
  ipv4Impl->SetIpv4 (ipv4);

  node->AggregateObject (ipv4);
  node->AggregateObject (arp);
  node->AggregateObject (ipv4Impl);
  node->AggregateObject (udpImpl);
  node->AggregateObject (tcpImpl);
  node->AggregateObject (ipv4L4Demux);
}

void 
AddGodArp (Ptr<Node> node)
{
  Ptr<Arp> arp = CreateObject<GodArp> ();
  node->AggregateObject (arp);
}

void 
AddRealArp (Ptr<Node> node)
{
  // XXX remove the PeekPointer below.
  Ptr<ArpL3Protocol> arp = CreateObject<ArpL3Protocol> ();
  arp->SetNode (node);
  node->RegisterProtocolHandler (MakeCallback (&ArpL3Protocol::Receive, PeekPointer (arp)),
                                 ArpL3Protocol::PROT_NUMBER, 0);
  node->AggregateObject (arp);
}

void 
AddAll (Ptr<Node> node)
{
  AddRealArp (node);
  AddIpv4 (node);
  AddUdp (node);
  AddTcp (node);
}


} // namespace InternetStack

}//namespace ns3





class Node;

namespace InternetStack {

void AddAll (Ptr<Node> node);
void AddGodArp (Ptr<Node> node);
void AddRealArp (Ptr<Node> node);
void AddIpv4 (Ptr<Node> node);
void AddUdp (Ptr<Node> node);
void AddTcp (Ptr<Node> node);

} // namespace InternetStack

}//namespace ns3


(-)a/src/internet-node/udp-socket.cc (-2 / +2 lines)

Lines 393-399 UdpSocketTest::RunTests (void)	Link Here

393

394

  // Receiver Node

394

  // Receiver Node

395

  Ptr<Node> rxNode = CreateObject<Node> ();

395

  Ptr<Node> rxNode = CreateObject<Node> ();

396

  AddInternetStack (rxNode);

396

  InternetStack::AddAll (rxNode);

397

  Ptr<SimpleNetDevice> rxDev1, rxDev2;

397

  Ptr<SimpleNetDevice> rxDev1, rxDev2;

398

  { // first interface

398

  { // first interface

399

    rxDev1 = CreateObject<SimpleNetDevice> ();

399

    rxDev1 = CreateObject<SimpleNetDevice> ();

Lines 419-425 UdpSocketTest::RunTests (void)	Link Here

419

420

  // Sender Node

420

  // Sender Node

421

  Ptr<Node> txNode = CreateObject<Node> ();

421

  Ptr<Node> txNode = CreateObject<Node> ();

422

  AddInternetStack (txNode);

422

  InternetStack::AddAll (txNode);

423

  Ptr<SimpleNetDevice> txDev1;

423

  Ptr<SimpleNetDevice> txDev1;

424

425

    txDev1 = CreateObject<SimpleNetDevice> ();

425

    txDev1 = CreateObject<SimpleNetDevice> ();

(-)a/src/internet-node/wscript (+2 lines)

Lines 17-22 def build(bld):	Link Here

        'ipv4-end-point.cc',

        'ipv4-end-point.cc',

        'udp-l4-protocol.cc',

        'udp-l4-protocol.cc',

        'tcp-l4-protocol.cc',

        'tcp-l4-protocol.cc',

        'arp.cc',

        'god-arp.cc',

        'arp-header.cc',

        'arp-header.cc',

        'arp-cache.cc',

        'arp-cache.cc',

        'arp-ipv4-interface.cc',

        'arp-ipv4-interface.cc',

Return to bug 187