Attachment #647 for bug #735

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




  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.IsEqual (iaddr.GetLocal ()))
        {
          NS_LOG_LOGIC ("For me (destination " << address << " match)");
          return true;
        }
      if (address.IsEqual (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 () == true)  // 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.IsEqual (iaddr.GetLocal ()))
                {
                  NS_LOG_LOGIC ("For me (destination " << address << " match) 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 169-174	Link Here

169

  int32_t GetInterfaceForAddress (Ipv4Address addr) const;

169

  int32_t GetInterfaceForAddress (Ipv4Address addr) const;

170

  int32_t GetInterfaceForPrefix (Ipv4Address addr, Ipv4Mask mask) const;

170

  int32_t GetInterfaceForPrefix (Ipv4Address addr, Ipv4Mask mask) const;

171

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

171

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

172

  bool IsDestinationAddress (Ipv4Address address, uint32_t iif) const;

172

173

  bool AddAddress (uint32_t i, Ipv4InterfaceAddress address);

174

  bool AddAddress (uint32_t i, Ipv4InterfaceAddress address);

174

  Ipv4InterfaceAddress GetAddress (uint32_t interfaceIndex, uint32_t addressIndex) const;

175

  Ipv4InterfaceAddress GetAddress (uint32_t interfaceIndex, uint32_t addressIndex) const;

Lines 199-206	Link Here

199

  Ipv4L3Protocol(const Ipv4L3Protocol &);

200

  Ipv4L3Protocol(const Ipv4L3Protocol &);

200

  Ipv4L3Protocol &operator = (const Ipv4L3Protocol &);

201

  Ipv4L3Protocol &operator = (const Ipv4L3Protocol &);

201

202

203

  // class Ipv4 attributes

202

  virtual void SetIpForward (bool forward);

204

  virtual void SetIpForward (bool forward);

203

  virtual bool GetIpForward (void) const;

205

  virtual bool GetIpForward (void) const;

206

  virtual void SetWeakEsModel (bool model);

207

  virtual bool GetWeakEsModel (void) const;

204

208

205

  Ipv4Header BuildHeader (

209

  Ipv4Header BuildHeader (

206

            Ipv4Address source,

210

            Ipv4Address source,

Lines 238-243	Link Here

238

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

242

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

239

243

240

  bool m_ipForward;

244

  bool m_ipForward;

245

  bool m_weakEsModel;

241

  L4List_t m_protocols;

246

  L4List_t m_protocols;

242

  Ipv4InterfaceList m_interfaces;

247

  Ipv4InterfaceList m_interfaces;

243

  uint32_t m_nInterfaces;

248

  uint32_t m_nInterfaces;

(-)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 (a subnet directed
   * broadcast must match the incoming interface).  If the attribute is
   * false, 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