Attachment #664 for bug #735

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

(-)a/CHANGES.html (-1 / +2 lines)

Lines 59-67	Link Here

by the ns-3 logging system to report the execution context of each log line.

by the ns-3 logging system to report the execution context of each log line.

<li><b>Object::DoStart</b>: Users who need to complete their object setup at the start of a simulation

<li><b>Object::DoStart</b>: Users who need to complete their object setup at the start of a simulation

can override this virtual method, perform their adhoc setup, and then, must chain up to their parent.

can override this virtual method, perform their adhoc setup, and then, must chain up to their parent.

<li><b>Aod hoc On-Demand Distance Vector (AODV)</b> routing model,

<li><b>Aod hoc On-Demand Distance Vector (AODV)</b> routing model,

<a href=http://www.ietf.org/rfc/rfc3561.txt>RFC 3561</a> </li>

<a href=http://www.ietf.org/rfc/rfc3561.txt>RFC 3561</a> </li>

<li><b>Ipv4::IsDestinationAddress (Ipv4Address address, uint32_t iif)</b> Method added to support checks of whether a destination address should be accepted

as one of the host's own addresses.  RFC 1122 Strong/Weak end system behavior can be changed with a new attribute (WeakEsModel) in class Ipv4.  </li>

</ul>

</ul>




  return -1;
}

bool
Ipv4L3Protocol::IsDestinationAddress (Ipv4Address address, uint32_t iif) const
{
  NS_LOG_FUNCTION (this << address << " " << iif);

  // First check the incoming interface for a unicast address match
  for (uint32_t i = 0; i < GetNAddresses (iif); i++)
    {
      Ipv4InterfaceAddress iaddr = GetAddress (iif, i);
      if (address == iaddr.GetLocal ())
        {
          NS_LOG_LOGIC ("For me (destination " << address << " match)");
          return true;
        }
      if (address == iaddr.GetBroadcast ())
        {
          NS_LOG_LOGIC ("For me (interface broadcast address)");
          return true;
        }
    }

  if (address.IsMulticast ())
    {
#ifdef NOTYET
      if (MulticastCheckGroup (iif, address ))
#endif
      if (true)
        {
          NS_LOG_LOGIC ("For me (Ipv4Addr multicast address");
          return true;
        }
    }

  if (address.IsBroadcast ())
    {
      NS_LOG_LOGIC ("For me (Ipv4Addr broadcast address)");
      return true;
    }

  if (GetWeakEsModel ())  // Check other interfaces
    { 
      for (uint32_t j = 0; j < GetNInterfaces (); j++)
        {
          if (j == uint32_t (iif)) continue;
          for (uint32_t i = 0; i < GetNAddresses (j); i++)
            {
              Ipv4InterfaceAddress iaddr = GetAddress (j, i);
              if (address == iaddr.GetLocal ())
                {
                  NS_LOG_LOGIC ("For me (destination " << address << " match) on another interface");
                  return true;
                }
              //  This is a small corner case:  match another interface's broadcast address
              if (address == iaddr.GetBroadcast ())
                {
                  NS_LOG_LOGIC ("For me (interface broadcast address on another interface)");
                  return true;
                }
            }
        }
    }
  return false;
}

void 
Ipv4L3Protocol::Receive( Ptr<NetDevice> device, Ptr<const Packet> p, uint16_t protocol, const Address &from,
                         const Address &to, NetDevice::PacketType packetType)

  return m_ipForward;
}

void 
Ipv4L3Protocol::SetWeakEsModel (bool model)
{
  m_weakEsModel = model;
}

bool 
Ipv4L3Protocol::GetWeakEsModel (void) const
{
  return m_weakEsModel;
}

void
Ipv4L3Protocol::RouteInputError (Ptr<const Packet> p, const Ipv4Header & ipHeader, Socket::SocketErrno sockErrno)
{

(-)a/src/internet-stack/ipv4-l3-protocol.h (+5 lines)

Lines 170-175	Link Here

170

  int32_t GetInterfaceForAddress (Ipv4Address addr) const;

170

  int32_t GetInterfaceForAddress (Ipv4Address addr) const;

171

  int32_t GetInterfaceForPrefix (Ipv4Address addr, Ipv4Mask mask) const;

171

  int32_t GetInterfaceForPrefix (Ipv4Address addr, Ipv4Mask mask) const;

172

  int32_t GetInterfaceForDevice (Ptr<const NetDevice> device) const;

172

  int32_t GetInterfaceForDevice (Ptr<const NetDevice> device) const;

173

  bool IsDestinationAddress (Ipv4Address address, uint32_t iif) const;

173

174

  bool AddAddress (uint32_t i, Ipv4InterfaceAddress address);

175

  bool AddAddress (uint32_t i, Ipv4InterfaceAddress address);

175

  Ipv4InterfaceAddress GetAddress (uint32_t interfaceIndex, uint32_t addressIndex) const;

176

  Ipv4InterfaceAddress GetAddress (uint32_t interfaceIndex, uint32_t addressIndex) const;

Lines 200-207	Link Here

200

  Ipv4L3Protocol(const Ipv4L3Protocol &);

201

  Ipv4L3Protocol(const Ipv4L3Protocol &);

201

  Ipv4L3Protocol &operator = (const Ipv4L3Protocol &);

202

  Ipv4L3Protocol &operator = (const Ipv4L3Protocol &);

202

203

204

  // class Ipv4 attributes

203

  virtual void SetIpForward (bool forward);

205

  virtual void SetIpForward (bool forward);

204

  virtual bool GetIpForward (void) const;

206

  virtual bool GetIpForward (void) const;

207

  virtual void SetWeakEsModel (bool model);

208

  virtual bool GetWeakEsModel (void) const;

205

209

206

  Ipv4Header BuildHeader (

210

  Ipv4Header BuildHeader (

207

            Ipv4Address source,

211

            Ipv4Address source,

Lines 239-244	Link Here

239

  typedef std::list<Ptr<Ipv4L4Protocol> > L4List_t;

243

  typedef std::list<Ptr<Ipv4L4Protocol> > L4List_t;

240

244

241

  bool m_ipForward;

245

  bool m_ipForward;

246

  bool m_weakEsModel;

242

  L4List_t m_protocols;

247

  L4List_t m_protocols;

243

  Ipv4InterfaceList m_interfaces;

248

  Ipv4InterfaceList m_interfaces;

244

  uint8_t m_defaultTtl;

249

  uint8_t m_defaultTtl;

(-)a/src/node/ipv4.cc (+6 lines)

Lines 37-42	Link Here

                   MakeBooleanAccessor (&Ipv4::SetIpForward,

                   MakeBooleanAccessor (&Ipv4::SetIpForward,

                                        &Ipv4::GetIpForward),

                                        &Ipv4::GetIpForward),

                   MakeBooleanChecker ())

                   MakeBooleanChecker ())

    .AddAttribute ("WeakEsModel",

                   "RFC1122 term for whether host accepts datagram with a dest. address on another interface",

                   BooleanValue (true),

                   MakeBooleanAccessor (&Ipv4::SetWeakEsModel,

                                        &Ipv4::GetWeakEsModel),

                   MakeBooleanChecker ())

#if 0

#if 0

    .AddAttribute ("MtuDiscover", "If enabled, every outgoing ip packet will have the DF flag set.",

    .AddAttribute ("MtuDiscover", "If enabled, every outgoing ip packet will have the DF flag set.",

                   BooleanValue (false),

                   BooleanValue (false),




   * This method searches the list of interfaces for one that holds a
   * particular address.  This call takes an IP address as a parameter and
   * returns the interface number of the first interface that has been assigned
   * that address, or -1 if not found.  There must be an exact match; this
   * method will not match broadcast or multicast addresses.
   */
  virtual int32_t GetInterfaceForAddress (Ipv4Address address) const = 0;

  /**
   * \brief Determine whether address and interface corresponding to
   *        received packet can be accepted for local delivery
   *
   * \param address The IP address being considered
   * \param iif The incoming Ipv4 interface index
   *
   * This method can be used to determine whether a received packet has
   * an acceptable address for local delivery on the host.  The address
   * may be a unicast, multicast, or broadcast address.  This method will
   * return true if address is an exact match of a unicast address on
   * one of the host's interfaces (see below), if address corresponds to 
   * a multicast group that the host has joined (and the incoming device
   * is acceptable), or if address corresponds to a broadcast address.
   *
   * If the Ipv4 attribute WeakEsModel is true, the unicast address may
   * match any of the Ipv4 addresses on any interface.  If the attribute is
   * false, the address must match one assigned to the incoming device.
   */
  virtual bool IsDestinationAddress (Ipv4Address address, uint32_t iif) const = 0;

  /**
   * \brief Return the interface number of first interface found that 
   *  has an Ipv4 address within the prefix specified by the input
   *  address and mask parameters

  // Indirect the Ipv4 attributes through private pure virtual methods
  virtual void SetIpForward (bool forward) = 0;
  virtual bool GetIpForward (void) const = 0;
  virtual void SetWeakEsModel (bool model) = 0;
  virtual bool GetWeakEsModel (void) const = 0;
};

} // namespace ns3 




  NS_ASSERT (m_ipv4->GetInterfaceForDevice (idev) >= 0);
  uint32_t iif = m_ipv4->GetInterfaceForDevice (idev); 

  retVal = m_ipv4->IsDestinationAddress (header.GetDestination (), iif);
  if (retVal == true)
  if (header.GetDestination().IsMulticast ())
    {
      NS_LOG_LOGIC ("Address "<< header.GetDestination () << " is a match for local delivery");
      if (header.GetDestination ().IsMulticast ())
#endif
      if (true)
        {
          NS_LOG_LOGIC ("Multicast packet for me-- local deliver");
          Ptr<Packet> packetCopy = p->Copy();
          // Here may want to disable lcb callback in recursive RouteInput
          // call below
          lcb (packetCopy, header, iif);
          // Fall through-- we may also need to forward this
          retVal = true;
          // Fall through
        }
      else
         m_routingProtocols.begin (); rprotoIter != m_routingProtocols.end ();
           rprotoIter++)
        {
          lcb (p, header, iif);
          return true;
            {
              retVal = true;
            }
        }
      return retVal;
    }

  if (header.GetDestination ().IsBroadcast ())
    {
      NS_LOG_LOGIC ("For me (Ipv4Addr broadcast address)");
      // TODO:  Local Deliver for broadcast
      // TODO:  Forward broadcast
    }

 // TODO:  Configurable option to enable RFC 1222 Strong End System Model
 // Right now, we will be permissive and allow a source to send us
 // a packet to one of our other interface addresses; that is, the
 // destination unicast address does not match one of the iif addresses,
 // but we check our other interfaces.  This could be an option
 // (to remove the outer loop immediately below and just check iif).
  for (uint32_t j = 0; j < m_ipv4->GetNInterfaces (); j++)
    {
      for (uint32_t i = 0; i < m_ipv4->GetNAddresses (j); i++)
        {
          Ipv4InterfaceAddress iaddr = m_ipv4->GetAddress (j, i);
          Ipv4Address addr = iaddr.GetLocal ();
          if (addr.IsEqual (header.GetDestination ()))
            {
              if (j == iif)
                {
                  NS_LOG_LOGIC ("For me (destination " << addr << " match)");
                }
              else
                {
                  NS_LOG_LOGIC ("For me (destination " << addr << " match) on another interface " << header.GetDestination ());
                }
              lcb (p, header, iif);
              return true;
            }
          if (header.GetDestination ().IsEqual (iaddr.GetBroadcast ()))
            {
              NS_LOG_LOGIC ("For me (interface broadcast address)");
              lcb (p, header, iif);
              return true;
            }
          NS_LOG_LOGIC ("Address "<< addr << " not a match");
        }
    }
  // Check if input device supports IP forwarding

      return false;
    }
  // Next, try to find a route
  // If we have already delivered a packet locally (e.g. multicast)
  // we suppress further downstream local delivery by nulling the callback
  LocalDeliverCallback downstreamLcb = lcb;
  if (retVal == true)
    {
      downstreamLcb = MakeNullCallback<void, Ptr<const Packet>, const Ipv4Header &, uint32_t > ();
    }
  for (Ipv4RoutingProtocolList::const_iterator rprotoIter =
         m_routingProtocols.begin ();
       rprotoIter != m_routingProtocols.end ();
       rprotoIter++)
    {
      if (retVal == false)
        {
          if ((*rprotoIter).second->RouteInput (p, header, idev, ucb, mcb, downstreamLcb, ecb))
            {
              return true;
            }
        }
    }
  // No routing protocol has found a route.  

Return to bug 735