Attachment #100 for bug #122

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




// a fine time to find the interface indices on node two.
//
  Ptr<Ipv4> ipv4;
  ipv4 = n2->QueryInterface<Ipv4> ();

  uint32_t ifIndexLan0 = ipv4->FindInterfaceForAddr (n2Lan0Addr);
  uint32_t ifIndexLan1 = ipv4->FindInterfaceForAddr (n2Lan1Addr);

// interface to find the output interface index, and tell node zero to send
// its multicast traffic out that interface.
//
  ipv4 = n0->QueryInterface<Ipv4> ();
  uint32_t ifIndexSrc = ipv4->FindInterfaceForAddr (multicastSource);
  ipv4->SetDefaultMulticastRoute (ifIndexSrc);
//

// multicast data.  To enable forwarding bits up the protocol stack, we need
// to tell the stack to join the multicast group.
//
  ipv4 = n4->QueryInterface<Ipv4> ();
  ipv4->JoinMulticastGroup (multicastSource, multicastGroup);
//
// Create an OnOff application to send UDP datagrams from node zero to the




  // This will likely set by some global StaticRouting object in the future
  NS_LOG_INFO ("Set Default Routes.");
  Ptr<Ipv4> ipv4;
  ipv4 = n0->QueryInterface<Ipv4> ();
  ipv4->SetDefaultRoute (Ipv4Address ("10.1.1.2"), 1);
  ipv4 = n3->QueryInterface<Ipv4> ();
  ipv4->SetDefaultRoute (Ipv4Address ("10.1.3.1"), 1);

  //

  NS_ASSERT (em != 0);
  // Now, query interface on the resulting em pointer to see if a 
  // RateErrorModel interface exists.  If so, set the packet error rate
  Ptr<RateErrorModel> bem = em->QueryInterface<RateErrorModel> ();
    (RateErrorModel::iid);
  if (bem)
    { 
      bem->SetRandomVariable (UniformVariable ());

(-)a/examples/simple-point-to-point-olsr.cc (-2 / +2 lines)

Lines 205-213 main (int argc, char *argv[])	Link Here

205

  // This will likely set by some global StaticRouting object in the future

205

  // This will likely set by some global StaticRouting object in the future

206

  NS_LOG_INFO ("Set Default Routes.");

206

  NS_LOG_INFO ("Set Default Routes.");

207

  Ptr<Ipv4> ipv4;

207

  Ptr<Ipv4> ipv4;

208

  ipv4 = n0->QueryInterface<Ipv4> (Ipv4::iid);

208

  ipv4 = n0->QueryInterface<Ipv4> ();

209

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.1.2"), 1);

209

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.1.2"), 1);

210

  ipv4 = n3->QueryInterface<Ipv4> (Ipv4::iid);

210

  ipv4 = n3->QueryInterface<Ipv4> ();

211

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.3.1"), 1);

211

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.3.1"), 1);

212

213

  // Configure tracing of all enqueue, dequeue, and NetDevice receive events

213

  // Configure tracing of all enqueue, dequeue, and NetDevice receive events

(-)a/examples/simple-point-to-point.cc (-2 / +2 lines)

Lines 206-214 main (int argc, char *argv[])	Link Here

206

  // This will likely set by some global StaticRouting object in the future

206

  // This will likely set by some global StaticRouting object in the future

207

  NS_LOG_INFO ("Set Default Routes.");

207

  NS_LOG_INFO ("Set Default Routes.");

208

  Ptr<Ipv4> ipv4;

208

  Ptr<Ipv4> ipv4;

209

  ipv4 = n0->QueryInterface<Ipv4> (Ipv4::iid);

209

  ipv4 = n0->QueryInterface<Ipv4> ();

210

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.1.2"), 1);

210

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.1.2"), 1);

211

  ipv4 = n3->QueryInterface<Ipv4> (Ipv4::iid);

211

  ipv4 = n3->QueryInterface<Ipv4> ();

212

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.3.1"), 1);

212

  ipv4->SetDefaultRoute (Ipv4Address ("10.1.3.1"), 1);

213

214

  // Configure tracing of all enqueue, dequeue, and NetDevice receive events

214

  // Configure tracing of all enqueue, dequeue, and NetDevice receive events




static void
SetPosition (Ptr<Node> node, Vector position)
{
  Ptr<MobilityModel> mobility = node->QueryInterface<MobilityModel> ();
  mobility->SetPosition (position);
}

static Vector
GetPosition (Ptr<Node> node)
{
  Ptr<MobilityModel> mobility = node->QueryInterface<MobilityModel> ();
  return mobility->GetPosition ();
}





static void
SetPosition (Ptr<Node> node, Vector position)
{
  Ptr<MobilityModel> mobility = node->QueryInterface<MobilityModel> ();
  mobility->SetPosition (position);
}

static Vector
GetPosition (Ptr<Node> node)
{
  Ptr<MobilityModel> mobility = node->QueryInterface<MobilityModel> ();
  return mobility->GetPosition ();
}


(-)a/samples/main-grid-topology.cc (-1 / +1 lines)

Lines 39-45 int main (int argc, char *argv[])	Link Here

       j != nodes.end (); j++)

       j != nodes.end (); j++)

      Ptr<Object> object = *j;

      Ptr<Object> object = *j;

      Ptr<MobilityModel> position = object->QueryInterface<MobilityModel> (MobilityModel::iid);

      Ptr<MobilityModel> position = object->QueryInterface<MobilityModel> ();

      NS_ASSERT (position != 0);

      NS_ASSERT (position != 0);

      Vector pos = position->GetPosition ();

      Vector pos = position->GetPosition ();

      std::cout << "x=" << pos.x << ", y=" << pos.y << ", z=" << pos.z << std::endl;

      std::cout << "x=" << pos.x << ", y=" << pos.y << ", z=" << pos.z << std::endl;




  bool ok = true;

  Ptr<A> a = 0;
  a = ComponentManager::Create<A> (A::cidZero);
  if (a == 0 ||
      !a->m_zeroInvoked)
    {
      ok = false;
    }

  a = ComponentManager::Create<A,bool> (A::cidOneBool, true);
  if (a == 0 ||
      !a->m_oneBoolInvoked ||
      !a->m_bool)

      ok = false;
    }

  a = ComponentManager::Create<A,bool> (A::cidOneBool, false);
  if (a == 0 ||
      !a->m_oneBoolInvoked ||
      a->m_bool)

      ok = false;
    }

  a = ComponentManager::Create<A,uint32_t> (A::cidOneUi32, 10);
  if (a == 0 ||
      !a->m_oneUi32Invoked ||
      a->m_ui32 != 10)

      ok = false;
    }

  a = ComponentManager::Create<A> (A::cidOneUi32, (uint32_t)10);
  if (a == 0 ||
      !a->m_oneUi32Invoked ||
      a->m_ui32 != 10)

      ok = false;
    }

  Ptr<B> b = ComponentManager::Create<B,uint32_t> (A::cidOneUi32, 10);
  if (b == 0)
    {
      ok = false;





  /**
   * \param classId class id of the constructor to invoke.
   * \param iid interface id to query for
   * \return a pointer to the instance created.
   *
   * Create an instance of the object identified by its

   * result.
   */
  template <typename T>
  static Ptr<T> Create (ClassId classId);

  /**
   * \param classId class id of the constructor to invoke.
   * \param iid interface id to query for
   * \param a1 first argument to pass to constructor
   * \return a pointer to the instance created.
   *

   * result.
   */
  template <typename T, typename T1>
  static Ptr<T> Create (ClassId classId, T1 a1);

  /**
   * \param classId class id of the constructor to invoke.
   * \param iid interface id to query for
   * \param a1 first argument to pass to constructor
   * \param a2 second argument to pass to constructor
   * \return a pointer to the instance created.

   * result.
   */
  template <typename T, typename T1, typename T2>
  static Ptr<T> Create (ClassId classId, T1 a1, T2 a2);

  /**
   * \param classId class id of the constructor to invoke.
   * \param iid interface id to query for
   * \param a1 first argument to pass to constructor
   * \param a2 second argument to pass to constructor
   * \param a3 third argument to pass to constructor

   * result.
   */
  template <typename T, typename T1, typename T2, typename T3>
  static Ptr<T> Create (ClassId classId, T1 a1, T2 a2, T3 a3);

  /**
   * \param classId class id of the constructor to invoke.
   * \param iid interface id to query for
   * \param a1 first argument to pass to constructor
   * \param a2 second argument to pass to constructor
   * \param a3 third argument to pass to constructor

   * result.
   */
  template <typename T, typename T1, typename T2, typename T3, typename T4>
  static Ptr<T> Create (ClassId classId, T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * \param classId class id of the constructor to invoke.
   * \param iid interface id to query for
   * \param a1 first argument to pass to constructor
   * \param a2 second argument to pass to constructor
   * \param a3 third argument to pass to constructor

   * result.
   */
  template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
  static Ptr<T> Create (ClassId classId, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

private:
  friend void RegisterCallback (ClassId classId, CallbackBase *callback, 
                                std::vector<const InterfaceId *> supportedInterfaces);
  static void Register (ClassId classId, CallbackBase *callback, 
                        std::vector<const InterfaceId *> supportedInterfaces);



template <typename T>
Ptr<T>
ComponentManager::Create (ClassId classId)
{
  Ptr<Object> obj = Create (classId);
  Ptr<T> i = obj->QueryInterface<T> ();
  return i;
}

template <typename T, typename T1>
Ptr<T>
ComponentManager::Create (ClassId classId, T1 a1)
{
  Ptr<Object> obj = Create (classId, a1);
  Ptr<T> i = obj->QueryInterface<T> ();
  return i;
}

template <typename T, typename T1, typename T2>
Ptr<T>
ComponentManager::Create (ClassId classId, T1 a1, T2 a2)
{
  Ptr<Object> obj = Create (classId, a1, a2);
  Ptr<T> i = obj->QueryInterface<T> ();
  return i;
}


template <typename T, typename T1, typename T2, typename T3>
Ptr<T>
ComponentManager::Create (ClassId classId, T1 a1, T2 a2, T3 a3)
{
  Ptr<Object> obj = Create (classId, a1, a2, a3);
  Ptr<T> i = obj->QueryInterface<T> ();
  return i;
}

template <typename T, typename T1, typename T2, typename T3, typename T4>
Ptr<T>
ComponentManager::Create (ClassId classId, T1 a1, T2 a2, T3 a3, T4 a4)
{
  Ptr<Object> obj = Create (classId, a1, a2, a3, a4);
  Ptr<T> i = obj->QueryInterface<T> ();
  return i;
}

template <typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
Ptr<T>
ComponentManager::Create (ClassId classId, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
  Ptr<Object> obj = Create (classId, a1, a2, a3, a4, a5);
  Ptr<T> i = obj->QueryInterface<T> ();
  return i;
}





  Ptr<Object> interface = m_aggregate->QueryInterface<Object> (interfaceId);
  return interface;
}
void  
InterfaceIdTraceResolver::Connect (std::string path, CallbackBase const &cb, const TraceContext &context)
{
  Ptr<const Object> interface = ParseForInterface (path);

  bool result = true;

  Ptr<BaseA> baseA = Create<BaseA> ();
  NS_TEST_ASSERT_EQUAL (baseA->QueryInterface<BaseA> (), baseA);
  NS_TEST_ASSERT_EQUAL (baseA->QueryInterface<BaseA> (DerivedA::iid), 0);
  NS_TEST_ASSERT_EQUAL (baseA->QueryInterface<DerivedA> (), 0);
  baseA = Create<DerivedA> (10);
  NS_TEST_ASSERT_EQUAL (baseA->QueryInterface<BaseA> (), baseA);
  NS_TEST_ASSERT_EQUAL (baseA->QueryInterface<BaseA> (DerivedA::iid), baseA);
  NS_TEST_ASSERT_UNEQUAL (baseA->QueryInterface<DerivedA> (), 0);

  baseA = Create<BaseA> ();
  Ptr<BaseB> baseB = Create<BaseB> ();
  Ptr<BaseB> baseBCopy = baseB;
  baseA->AddInterface (baseB);
  NS_TEST_ASSERT_UNEQUAL (baseA->QueryInterface<BaseA> (), 0);
  NS_TEST_ASSERT_EQUAL (baseA->QueryInterface<DerivedA> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseA->QueryInterface<BaseB> (), 0);
  NS_TEST_ASSERT_EQUAL (baseA->QueryInterface<DerivedB> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseB->QueryInterface<BaseB> (), 0);
  NS_TEST_ASSERT_EQUAL (baseB->QueryInterface<DerivedB> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseB->QueryInterface<BaseA> (), 0);
  NS_TEST_ASSERT_EQUAL (baseB->QueryInterface<DerivedA> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseBCopy->QueryInterface<BaseA> (), 0);

  baseA = Create<DerivedA> (1);
  baseB = Create<DerivedB> (1);
  baseBCopy = baseB;
  baseA->AddInterface (baseB);
  NS_TEST_ASSERT_UNEQUAL (baseA->QueryInterface<DerivedB> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseA->QueryInterface<BaseB> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseB->QueryInterface<DerivedA> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseB->QueryInterface<BaseA> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseBCopy->QueryInterface<DerivedA> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseBCopy->QueryInterface<BaseA> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseB->QueryInterface<DerivedB> (), 0);
  NS_TEST_ASSERT_UNEQUAL (baseB->QueryInterface<BaseB> (), 0)

  baseA = Create<BaseA> ();
  baseB = Create<BaseB> ();
  baseA->AddInterface (baseB);
  baseA = 0;
  baseA = baseB->QueryInterface<BaseA> ();

  baseA = Create<BaseA> ();
  baseA->TraceConnect ("/basea-x", MakeCallback (&ObjectTest::BaseATrace, this));




   */
  inline void Unref (void) const;
  /**
   * \param iid the interface requested
   * \returns a pointer to the requested interface or zero if it could not be found.
   */
  template <typename T>
  Ptr<T> QueryInterface (void) const;
  /**
   * \param iid the interface id of the requested interface
   * \returns a pointer to the requested interface or zero if it could not be found.
   */
  template <typename T>
  Ptr<T> QueryInterface (InterfaceId iid) const;

  virtual void DoDispose (void);
private:
  friend class InterfaceIdTraceResolver;
  Ptr<Object> DoQueryInterface (InterfaceId iid) const;
  void DoCollectSources (std::string path, const TraceContext &context, 
                         TraceResolver::SourceCollection *collection) const;
  Ptr<Object> DoQueryInterface (InterfaceId iid) const;
  void DoTraceAll (std::ostream &os, const TraceContext &context) const;
  bool Check (void) const;
  bool CheckLoose (void) const;


template <typename T>
Ptr<T> 
Object::QueryInterface () const
{
  Ptr<Object> found = DoQueryInterface (T::iid);
  if (found != 0)
    {
      return Ptr<T> (dynamic_cast<T *> (PeekPointer (found)));
    }
  return 0;
}

template <typename T>
Ptr<T> 
Object::QueryInterface (InterfaceId iid) const
{
  Ptr<Object> found = DoQueryInterface (iid);

(-)a/src/devices/csma/csma-ipv4-topology.cc (-3 / +3 lines)

Lines 101-107 CsmaIpv4Topology::AddIpv4Address(	Link Here

101

102

  Ptr<NetDevice> nd = node->GetDevice(netDeviceNumber);

102

  Ptr<NetDevice> nd = node->GetDevice(netDeviceNumber);

103

104

  Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> (Ipv4::iid);

104

  Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> ();

105

  uint32_t ifIndex = ipv4->AddInterface (nd);

105

  uint32_t ifIndex = ipv4->AddInterface (nd);

106

107

  ipv4->SetAddress (ifIndex, address);

107

  ipv4->SetAddress (ifIndex, address);

Lines 116-123 CsmaIpv4Topology::AddIpv4Routes (	Link Here

116

  Ptr<NetDevice> nd1, Ptr<NetDevice> nd2)

116

  Ptr<NetDevice> nd1, Ptr<NetDevice> nd2)

117

118

  // Assert that both are Ipv4 nodes

118

  // Assert that both are Ipv4 nodes

119

  Ptr<Ipv4> ip1 = nd1->GetNode ()->QueryInterface<Ipv4> (Ipv4::iid);

119

  Ptr<Ipv4> ip1 = nd1->GetNode ()->QueryInterface<Ipv4> ();

120

  Ptr<Ipv4> ip2 = nd2->GetNode ()->QueryInterface<Ipv4> (Ipv4::iid);

120

  Ptr<Ipv4> ip2 = nd2->GetNode ()->QueryInterface<Ipv4> ();

121

  NS_ASSERT(ip1 != 0 && ip2 != 0);

121

  NS_ASSERT(ip1 != 0 && ip2 != 0);

122

123

  // Get interface indexes for both nodes corresponding to the right channel

123

  // Get interface indexes for both nodes corresponding to the right channel




  NS_ASSERT (nd1->GetNode ()->GetId () == n1->GetId ());
  NS_ASSERT (nd2->GetNode ()->GetId () == n2->GetId ());
  
  Ptr<Ipv4> ip1 = n1->QueryInterface<Ipv4> ();
  uint32_t index1 = ip1->AddInterface (nd1);

  ip1->SetAddress (index1, addr1);
  ip1->SetNetworkMask (index1, netmask);
  ip1->SetUp (index1);

  Ptr<Ipv4> ip2 = n2->QueryInterface<Ipv4> ();
  uint32_t index2 = ip2->AddInterface (nd2);

  ip2->SetAddress (index2, addr2);

  // Get interface indexes for both nodes corresponding to the right channel
  uint32_t index = 0;
  bool found = false;
  Ptr<Ipv4> ip1 = n1->QueryInterface<Ipv4> ();
  for (uint32_t i = 0; i < ip1->GetNInterfaces (); i++)
    {
      if (ip1 ->GetNetDevice (i) == nd1)


  index = 0;
  found = false;
  Ptr<Ipv4> ip2 = n2->QueryInterface<Ipv4> ();
  for (uint32_t i = 0; i < ip2->GetNInterfaces (); i++)
    {
      if (ip2 ->GetNetDevice (i) == nd2)

    }

  // Assert that both are Ipv4 nodes
  Ptr<Ipv4> ip1 = nd1->GetNode ()->QueryInterface<Ipv4> ();
  Ptr<Ipv4> ip2 = nd2->GetNode ()->QueryInterface<Ipv4> ();
  NS_ASSERT(ip1 != 0 && ip2 != 0);

  // Get interface indexes for both nodes corresponding to the right channel




WifiChannel::Send (Ptr<NetDevice> sender, Ptr<const Packet> packet, double txPowerDbm,
                   WifiMode wifiMode, WifiPreamble preamble) const
{
  Ptr<MobilityModel> senderMobility = sender->GetNode ()->QueryInterface<MobilityModel> ();
  uint32_t j = 0;
  for (DeviceList::const_iterator i = m_deviceList.begin (); i != m_deviceList.end (); i++)
    {
      if (sender != i->first)
        {
          Ptr<MobilityModel> receiverMobility = i->first->GetNode ()->QueryInterface<MobilityModel> ();
          Time delay = m_delay->GetDelay (senderMobility, receiverMobility);
          double rxPowerDbm = m_loss->GetRxPower (txPowerDbm, senderMobility, receiverMobility);
          NS_LOG_DEBUG ("propagation: txPower="<<txPowerDbm<<"dbm, rxPower="<<rxPowerDbm<<"dbm, "<<

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

Lines 71-77 ArpIpv4Interface::SendTo (Ptr<Packet> p,	Link Here

      NS_LOG_LOGIC ("Needs ARP");

      NS_LOG_LOGIC ("Needs ARP");

      Ptr<ArpL3Protocol> arp =

      Ptr<ArpL3Protocol> arp =

        m_node->QueryInterface<ArpL3Protocol> (ArpL3Protocol::iid);

        m_node->QueryInterface<ArpL3Protocol> ();

      Address hardwareDestination;

      Address hardwareDestination;

      bool found;

      bool found;

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

Lines 72-78 ArpL3Protocol::FindCache (Ptr<NetDevice>	Link Here

	  return *i;

	  return *i;

  Ptr<Ipv4L3Protocol> ipv4 = m_node->QueryInterface<Ipv4L3Protocol> (Ipv4L3Protocol::iid);

  Ptr<Ipv4L3Protocol> ipv4 = m_node->QueryInterface<Ipv4L3Protocol> ();

  Ptr<Ipv4Interface> interface = ipv4->FindInterfaceForDevice (device);

  Ptr<Ipv4Interface> interface = ipv4->FindInterfaceForDevice (device);

  ArpCache * cache = new ArpCache (device, interface);

  ArpCache * cache = new ArpCache (device, interface);

  NS_ASSERT (device->IsBroadcast ());

  NS_ASSERT (device->IsBroadcast ());

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

Lines 78-84 InternetNode::GetTraceResolver () const	Link Here

InternetNode::GetTraceResolver () const

InternetNode::GetTraceResolver () const

  Ptr<CompositeTraceResolver> resolver = Create<CompositeTraceResolver> ();

  Ptr<CompositeTraceResolver> resolver = Create<CompositeTraceResolver> ();

  Ptr<Ipv4L3Protocol> ipv4 = QueryInterface<Ipv4L3Protocol> (Ipv4L3Protocol::iid);

  Ptr<Ipv4L3Protocol> ipv4 = QueryInterface<Ipv4L3Protocol> ();

  resolver->AddComposite ("ipv4", ipv4);

  resolver->AddComposite ("ipv4", ipv4);

  resolver->SetParentResolver (Node::GetTraceResolver ());

  resolver->SetParentResolver (Node::GetTraceResolver ());

  return resolver;

  return resolver;

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

Lines 743-749 Ipv4L3Protocol::ForwardUp (Ptr<Packet> p	Link Here

743

  NS_LOG_FUNCTION;

743

  NS_LOG_FUNCTION;

744

  NS_LOG_PARAMS (this << p << &ip);

744

  NS_LOG_PARAMS (this << p << &ip);

745

746

  Ptr<Ipv4L4Demux> demux = m_node->QueryInterface<Ipv4L4Demux> (Ipv4L4Demux::iid);

746

  Ptr<Ipv4L4Demux> demux = m_node->QueryInterface<Ipv4L4Demux> ();

747

  Ptr<Ipv4L4Protocol> protocol = demux->GetProtocol (ip.GetProtocol ());

747

  Ptr<Ipv4L4Protocol> protocol = demux->GetProtocol (ip.GetProtocol ());

748

  protocol->Receive (p, ip.GetSource (), ip.GetDestination (), incomingInterface);

748

  protocol->Receive (p, ip.GetSource (), ip.GetDestination (), incomingInterface);

749

(-)a/src/internet-node/ipv4-loopback-interface.cc (-1 / +1 lines)

Lines 51-57 Ipv4LoopbackInterface::SendTo (Ptr<Packe	Link Here

  NS_LOG_PARAMS (this << packet << dest);

  NS_LOG_PARAMS (this << packet << dest);

  Ptr<Ipv4L3Protocol> ipv4 =

  Ptr<Ipv4L3Protocol> ipv4 =

    m_node->QueryInterface<Ipv4L3Protocol> (Ipv4L3Protocol::iid);

    m_node->QueryInterface<Ipv4L3Protocol> ();

  ipv4->Receive (0, packet, Ipv4L3Protocol::PROT_NUMBER,

  ipv4->Receive (0, packet, Ipv4L3Protocol::PROT_NUMBER,

                 Mac48Address ("ff:ff:ff:ff:ff:ff"));

                 Mac48Address ("ff:ff:ff:ff:ff:ff"));

(-)a/src/internet-node/udp-l4-protocol.cc (-1 / +1 lines)

Lines 159-165 UdpL4Protocol::Send (Ptr<Packet> packet,	Link Here

159

160

  packet->AddHeader (udpHeader);

160

  packet->AddHeader (udpHeader);

161

162

  Ptr<Ipv4L3Protocol> ipv4 = m_node->QueryInterface<Ipv4L3Protocol> (Ipv4L3Protocol::iid);

162

  Ptr<Ipv4L3Protocol> ipv4 = m_node->QueryInterface<Ipv4L3Protocol> ();

163

  if (ipv4 != 0)

163

  if (ipv4 != 0)

164

165

      NS_LOG_LOGIC ("Sending to IP");

165

      NS_LOG_LOGIC ("Sending to IP");




    }

  uint32_t localIfIndex;
  Ptr<Ipv4> ipv4 = m_node->QueryInterface<Ipv4> ();

  //
  // If dest is sent to the limited broadcast address (all ones),

  Ptr<Node> rxNode = Create<InternetNode> ();
  Ptr<PointToPointNetDevice> rxDev = Create<PointToPointNetDevice> (rxNode);
  rxDev->AddQueue(Create<DropTailQueue> ());
  Ptr<Ipv4> ipv4 = rxNode->QueryInterface<Ipv4> ();
  uint32_t netdev_idx = ipv4->AddInterface (rxDev);
  ipv4->SetAddress (netdev_idx, Ipv4Address ("10.0.0.1"));
  ipv4->SetNetworkMask (netdev_idx, Ipv4Mask (0xffff0000U));

  Ptr<Node> txNode = Create<InternetNode> ();
  Ptr<PointToPointNetDevice> txDev = Create<PointToPointNetDevice> (txNode);
  txDev->AddQueue(Create<DropTailQueue> ());
  ipv4 = txNode->QueryInterface<Ipv4> ();
  netdev_idx = ipv4->AddInterface (txDev);
  ipv4->SetAddress (netdev_idx, Ipv4Address ("10.0.0.2"));
  ipv4->SetNetworkMask (netdev_idx, Ipv4Mask (0xffff0000U));



  // Create the UDP sockets
  Ptr<SocketFactory> rxSocketFactory = rxNode->QueryInterface<Udp> ();
  Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();
  NS_TEST_ASSERT_EQUAL (rxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.0.2"), 1234)), 0);
  rxSocket->SetRecvCallback (MakeCallback (&UdpSocketTest::ReceivePacket, this));

  Ptr<SocketFactory> txSocketFactory = txNode->QueryInterface<Udp> ();
  Ptr<Socket> txSocket = txSocketFactory->CreateSocket ();

  // ------ Now the tests ------------

(-)a/src/mobility/hierarchical-mobility-model.cc (-2 / +2 lines)

Lines 27-35 HierarchicalMobilityModel::HierarchicalM	Link Here

    m_parent (parent)

    m_parent (parent)

  Ptr<MobilityModelNotifier> childNotifier =

  Ptr<MobilityModelNotifier> childNotifier =

    m_child->QueryInterface<MobilityModelNotifier> (MobilityModelNotifier::iid);

    m_child->QueryInterface<MobilityModelNotifier> ();

  Ptr<MobilityModelNotifier> parentNotifier =

  Ptr<MobilityModelNotifier> parentNotifier =

    m_parent->QueryInterface<MobilityModelNotifier> (MobilityModelNotifier::iid);

    m_parent->QueryInterface<MobilityModelNotifier> ();

  if (childNotifier == 0)

  if (childNotifier == 0)

      childNotifier = Create<MobilityModelNotifier> ();

      childNotifier = Create<MobilityModelNotifier> ();

(-)a/src/mobility/mobility-model.cc (-2 / +1 lines)

Lines 61-68 void	Link Here

void

void

MobilityModel::NotifyCourseChange (void) const

MobilityModel::NotifyCourseChange (void) const

  Ptr<MobilityModelNotifier> notifier =

  Ptr<MobilityModelNotifier> notifier = QueryInterface<MobilityModelNotifier> ();

    QueryInterface<MobilityModelNotifier> (MobilityModelNotifier::iid);

  if (notifier != 0)

  if (notifier != 0)

      notifier->Notify (this);

      notifier->Notify (this);

(-)a/src/mobility/ns2-mobility-file-topology.cc (-2 / +1 lines)

Lines 49-56 Ns2MobilityFileTopology::GetMobilityMode	Link Here

      return 0;

      return 0;

  Ptr<StaticSpeedMobilityModel> model =

  Ptr<StaticSpeedMobilityModel> model = object->QueryInterface<StaticSpeedMobilityModel> ();

    object->QueryInterface<StaticSpeedMobilityModel> (StaticSpeedMobilityModel::iid);

  if (model == 0)

  if (model == 0)

      model = Create<StaticSpeedMobilityModel> ();

      model = Create<StaticSpeedMobilityModel> ();

(-)a/src/node/packet-socket-factory.cc (-1 / +1 lines)

Lines 34-40 PacketSocketFactory::PacketSocketFactory	Link Here

Ptr<Socket> PacketSocketFactory::CreateSocket (void)

Ptr<Socket> PacketSocketFactory::CreateSocket (void)

  Ptr<Node> node = QueryInterface<Node> (Node::iid);

  Ptr<Node> node = QueryInterface<Node> ();

  Ptr<PacketSocket> socket = Create<PacketSocket> (node);

  Ptr<PacketSocket> socket = Create<PacketSocket> (node);

  return socket;

  return socket;




      Ptr<Node> node = *i;

      Ptr<GlobalRouter> rtr = 
        node->QueryInterface<GlobalRouter> ();
//      
// Ignore nodes that aren't participating in routing.
//

// participating in routing.
//
      Ptr<GlobalRouter> rtr = 
        node->QueryInterface<GlobalRouter> ();
//
// if the node has a global router interface, then run the global routing
// algorithms.

      Ptr<Node> node = *i;

      Ptr<GlobalRouter> rtr = 
        node->QueryInterface<GlobalRouter> ();
//
// If the node doesn't have a GlobalRouter interface it can't be the one
// we're interested in.

// is participating in routing IP version 4 packets, it certainly must have 
// an Ipv4 interface.
//
          Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> ();
          NS_ASSERT_MSG (ipv4, 
            "GlobalRouteManagerImpl::FindOutgoingInterfaceId (): "
            "QI for <Ipv4> interface failed");

// in question cannot be the router we want, so we continue.
// 
      Ptr<GlobalRouter> rtr = 
        node->QueryInterface<GlobalRouter> ();

      if (rtr == 0)
        {

// for that interface.  If the node is acting as an IP version 4 router, it
// should absolutely have an Ipv4 interface.
//
          Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> ();
          NS_ASSERT_MSG (ipv4, 
            "GlobalRouteManagerImpl::SPFIntraAddRouter (): "
            "QI for <Ipv4> interface failed");

// in question cannot be the router we want, so we continue.
// 
      Ptr<GlobalRouter> rtr = 
        node->QueryInterface<GlobalRouter> ();

      if (rtr == 0)
        {

// for that interface.  If the node is acting as an IP version 4 router, it
// should absolutely have an Ipv4 interface.
//
          Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> ();
          NS_ASSERT_MSG (ipv4, 
            "GlobalRouteManagerImpl::SPFIntraAddTransit (): "
            "QI for <Ipv4> interface failed");




GlobalRouter::DiscoverLSAs (void)
{
  NS_LOG_FUNCTION;
  Ptr<Node> node = QueryInterface<Node> ();
  NS_LOG_LOGIC("For node " << node->GetId () );
  NS_ASSERT_MSG(node, 
    "GlobalRouter::DiscoverLSAs (): <Node> interface not set");

// Ipv4 interface.  This is where the information regarding the attached 
// interfaces lives.
//
  Ptr<Ipv4> ipv4Local = node->QueryInterface<Ipv4> ();
  NS_ASSERT_MSG(ipv4Local, 
    "GlobalRouter::DiscoverLSAs (): QI for <Ipv4> interface failed");
//

// device for its node, then ask that node for its Ipv4 interface.
//
          Ptr<Node> nodeRemote = ndRemote->GetNode();
          Ptr<Ipv4> ipv4Remote = nodeRemote->QueryInterface<Ipv4> ();
          NS_ASSERT_MSG(ipv4Remote, 
            "GlobalRouter::DiscoverLSAs (): QI for remote <Ipv4> failed");
//

// well get it now.
//
          Ptr<GlobalRouter> srRemote = 
            nodeRemote->QueryInterface<GlobalRouter> ();
          NS_ASSERT_MSG(srRemote, 
            "GlobalRouter::DiscoverLSAs():QI for remote <GlobalRouter> failed");
          Ipv4Address rtrIdRemote = srRemote->GetRouterId();

              NS_ASSERT (tempNd);
              Ptr<Node> tempNode = tempNd->GetNode ();
              uint32_t tempIfIndex = FindIfIndexForDevice (tempNode, tempNd);
              Ptr<Ipv4> tempIpv4 = tempNode->QueryInterface<Ipv4> ();
              NS_ASSERT (tempIpv4);
              Ipv4Address tempAddr = tempIpv4->GetAddress(tempIfIndex);
              pLSA->AddAttachedRouter (tempAddr);

  Ptr<NetDevice> ndLocal) const
{
  uint32_t ifIndexLocal = FindIfIndexForDevice(node, ndLocal);
  Ptr<Ipv4> ipv4Local = QueryInterface<Ipv4> ();
  NS_ASSERT (ipv4Local);
  Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);
  Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

      NS_ASSERT (tempNd);
      Ptr<Node> tempNode = tempNd->GetNode ();
      uint32_t tempIfIndex = FindIfIndexForDevice (tempNode, tempNd);
      Ptr<Ipv4> tempIpv4 = tempNode->QueryInterface<Ipv4> ();
      NS_ASSERT (tempIpv4);
      Ipv4Address tempAddr = tempIpv4->GetAddress(tempIfIndex);
      if (tempAddr < addrLocal)

GlobalRouter::FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd) const
{
  NS_LOG_FUNCTION;
  Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> ();
  NS_ASSERT_MSG(ipv4, "QI for <Ipv4> interface failed");
  for (uint32_t i = 0; i < ipv4->GetNInterfaces(); ++i )
    {

(-)a/src/routing/olsr/olsr-agent-impl.cc (-1 / +1 lines)

Lines 178-184 AgentImpl::AgentImpl (Ptr<Node> node)	Link Here

178

179

  m_linkTupleTimerFirstTime = true;

179

  m_linkTupleTimerFirstTime = true;

180

181

  m_ipv4 = node->QueryInterface<Ipv4> (Ipv4::iid);

181

  m_ipv4 = node->QueryInterface<Ipv4> ();

182

  NS_ASSERT (m_ipv4);

182

  NS_ASSERT (m_ipv4);

183

184

  Ptr<SocketFactory> socketFactory = node->QueryInterface<SocketFactory> (Udp::iid);

184

  Ptr<SocketFactory> socketFactory = node->QueryInterface<SocketFactory> (Udp::iid);

(-)a/src/routing/olsr/olsr.cc (-1 / +1 lines)

Lines 34-40 EnableNode (Ptr<Node> node)	Link Here

EnableNode (Ptr<Node> node)

EnableNode (Ptr<Node> node)

  ComponentManager::Create<olsr::Agent, Ptr<Node> >

  ComponentManager::Create<olsr::Agent, Ptr<Node> >

    (olsr::Agent::cid, olsr::Agent::iid, node)->Start ();

    (olsr::Agent::cid, node)->Start ();

(-)a/tutorial/point-to-point-ipv4-topology.cc (-1 / +1 lines)

Lines 60-66 PointToPointIpv4Topology::AddAddress (	Link Here

  Ipv4Mask mask)

  Ipv4Mask mask)

  Ptr<NetDevice> nd = node->GetDevice(netDeviceNumber);

  Ptr<NetDevice> nd = node->GetDevice(netDeviceNumber);

  Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> (Ipv4::iid);

  Ptr<Ipv4> ipv4 = node->QueryInterface<Ipv4> ();

  uint32_t ifIndex = ipv4->AddInterface (nd);

  uint32_t ifIndex = ipv4->AddInterface (nd);

  ipv4->SetAddress (ifIndex, address);

  ipv4->SetAddress (ifIndex, address);

(-)a/utils/mobility-visualizer-model.cc (-1 / +1 lines)

Lines 47-53 Sample ()	Link Here

  for (NodeList::Iterator nodeIter = NodeList::Begin (); nodeIter != NodeList::End (); nodeIter++)

  for (NodeList::Iterator nodeIter = NodeList::Begin (); nodeIter != NodeList::End (); nodeIter++)

      Ptr<Node> node = *nodeIter;

      Ptr<Node> node = *nodeIter;

      Ptr<MobilityModel> mobility = node->QueryInterface<MobilityModel> (MobilityModel::iid);

      Ptr<MobilityModel> mobility = node->QueryInterface<MobilityModel> ();

      Vector pos = mobility->GetPosition ();

      Vector pos = mobility->GetPosition ();

      Vector vel = mobility->GetVelocity ();

      Vector vel = mobility->GetVelocity ();

Return to bug 122