Attachment #2974 for bug #2834

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




  bool AddAllocated (const Ipv4Address addr);

  /**
   * \brief Check the Ipv4Address allocation in the list of IPv4 entries
   *
   * \param addr The Ipv4Address to be checked in the list of Ipv4 entries
   * \returns true if the address is already allocated
   */
  bool CheckAllocated (const Ipv4Address addr);

  /**
   * \brief Check if a network has already allocated addresses
   *
   * \param addr The Ipv4 network to be checked
   * \param mask The Ipv4 network mask
   * \returns true if the network is already allocated
   */
  bool IsNetworkAllocated (const Ipv4Address addr, const Ipv4Mask mask);

  /**
   * \brief Used to turn off fatal errors and assertions, for testing
   */
  void TestMode (void);

// If we get here, we know that the next lower block of addresses couldn't 
// have been extended to include this new address since the code immediately 
// above would have been executed and that next lower block extended upward.
// So we know it's safe to extend the current block down to include the new
// address.
//
      if (addr == (*i).addrLow - 1)

  return true;
}

bool
Ipv4AddressGeneratorImpl::CheckAllocated (const Ipv4Address address)
{
  NS_LOG_FUNCTION (this << address);

  uint32_t addr = address.Get ();

  NS_ABORT_MSG_UNLESS (addr, "Ipv4AddressGeneratorImpl::CheckAllocated(): Don't check for the broadcast address...");

  std::list<Entry>::iterator i;

  for (i = m_entries.begin (); i != m_entries.end (); ++i)
    {
      NS_LOG_LOGIC ("examine entry: " << Ipv4Address ((*i).addrLow) <<
                    " to " << Ipv4Address ((*i).addrHigh));
      if (addr >= (*i).addrLow && addr <= (*i).addrHigh)
        {
          NS_LOG_LOGIC ("Ipv4AddressGeneratorImpl::CheckAllocated(): Address Collision: " << Ipv4Address (addr));
          return false;
        }
    }
  return true;
}

bool
Ipv4AddressGeneratorImpl::IsNetworkAllocated (const Ipv4Address address, const Ipv4Mask mask)
{
  NS_LOG_FUNCTION (this << address << mask);

  NS_ABORT_MSG_UNLESS (address == address.CombineMask (mask),
                       "Ipv4AddressGeneratorImpl::IsNetworkAllocated(): network address and mask don't match " << address << " " << mask);

  std::list<Entry>::iterator i;

  for (i = m_entries.begin (); i != m_entries.end (); ++i)
    {
      NS_LOG_LOGIC ("examine entry: " << Ipv4Address ((*i).addrLow) << " to " << Ipv4Address ((*i).addrHigh));
      Ipv4Address low = Ipv4Address ((*i).addrLow);
      Ipv4Address high = Ipv4Address ((*i).addrHigh);

      if (address == low.CombineMask (mask) || address == high.CombineMask (mask))
        {
          NS_LOG_LOGIC ("Ipv4AddressGeneratorImpl::IsNetworkAllocated(): Network already allocated: " <<
                        address << " " << low << "-" << high);
          return false;
        }

    }
  return true;
}


void
Ipv4AddressGeneratorImpl::TestMode (void)
{

         ->AddAllocated (addr);
}

bool
Ipv4AddressGenerator::CheckAllocated (const Ipv4Address addr)
{
  NS_LOG_FUNCTION_NOARGS ();

  return SimulationSingleton<Ipv4AddressGeneratorImpl>::Get ()
         ->CheckAllocated (addr);
}

bool
Ipv4AddressGenerator::IsNetworkAllocated (const Ipv4Address addr, const Ipv4Mask mask)
{
  NS_LOG_FUNCTION_NOARGS ();

  return SimulationSingleton<Ipv4AddressGeneratorImpl>::Get ()
         ->IsNetworkAllocated (addr, mask);
}

void
Ipv4AddressGenerator::TestMode (void)
{




  static bool AddAllocated (const Ipv4Address addr);

  /**
   * \brief Check the Ipv4Address allocation in the list of IPv4 entries
   *
   * \param addr The Ipv4Address to be checked in the list of Ipv4 entries
   * \returns true if the network is already allocated
   */
  static bool CheckAllocated (const Ipv4Address addr);

  /**
   * \brief Check if a network has already allocated addresses
   *
   * \param addr The Ipv4 network to be checked
   * \param mask The Ipv4 network mask
   * \returns true if the network is already allocated
   */
  static bool IsNetworkAllocated (const Ipv4Address addr, const Ipv4Mask mask);

  /**
   * \brief Used to turn off fatal errors and assertions, for testing
   */
  static void TestMode (void);




  bool AddAllocated (const Ipv6Address addr);

  /**
   * \brief Check the Ipv6Address allocation in the list of IPv6 entries
   *
   * \param addr The Ipv6Address to be checked in the list of Ipv4 entries
   * \returns true if the network is already allocated
   */
  bool CheckAllocated (const Ipv6Address addr);

  /**
   * \brief Check if a network has already allocated addresses
   *
   * \param addr The Ipv6 network to be checked
   * \param prefix The Ipv6 network prefix
   * \returns true if the network is already allocated
   */
  bool IsNetworkAllocated (const Ipv6Address addr, const Ipv6Prefix prefix);

  /**
   * \brief Used to turn off fatal errors and assertions, for testing
   */
  void TestMode (void);

  return true;
}

bool
Ipv6AddressGeneratorImpl::CheckAllocated (const Ipv6Address address)
{
  NS_LOG_FUNCTION (this << address);

  uint8_t addr[16];
  address.GetBytes (addr);

  std::list<Entry>::iterator i;

  for (i = m_entries.begin (); i != m_entries.end (); ++i)
    {
      NS_LOG_LOGIC ("examine entry: " << Ipv6Address ((*i).addrLow) <<
                    " to " << Ipv6Address ((*i).addrHigh));

      if (!(Ipv6Address (addr) < Ipv6Address ((*i).addrLow))
          && ((Ipv6Address (addr) < Ipv6Address ((*i).addrHigh))
              || (Ipv6Address (addr) == Ipv6Address ((*i).addrHigh))))
        {
          NS_LOG_LOGIC ("Ipv6AddressGeneratorImpl::CheckAllocated(): Address Collision: " << Ipv6Address (addr));
          return false;
        }
    }
  return true;
}

bool
Ipv6AddressGeneratorImpl::IsNetworkAllocated (const Ipv6Address address, const Ipv6Prefix prefix)
{
  NS_LOG_FUNCTION (this << address << prefix);

  Ipv6Address addr = address;
  NS_ABORT_MSG_UNLESS (address == addr.CombinePrefix (prefix),
                       "Ipv6AddressGeneratorImpl::IsNetworkAllocated(): network address and mask don't match " << address << " " << prefix);

  std::list<Entry>::iterator i;

  for (i = m_entries.begin (); i != m_entries.end (); ++i)
    {
      NS_LOG_LOGIC ("examine entry: " << Ipv6Address ((*i).addrLow) << " to " << Ipv6Address ((*i).addrHigh));
      Ipv6Address low = Ipv6Address ((*i).addrLow);
      Ipv6Address high = Ipv6Address ((*i).addrHigh);

      if (address == low.CombinePrefix (prefix) || address == high.CombinePrefix (prefix))
        {
          NS_LOG_LOGIC ("Ipv6AddressGeneratorImpl::IsNetworkAllocated(): Network already allocated: " <<
                        address << " " << low << "-" << high);
          return false;
        }

    }
  return true;
}


void
Ipv6AddressGeneratorImpl::TestMode (void)
{

         ->AddAllocated (addr);
}

bool
Ipv6AddressGenerator::CheckAllocated (const Ipv6Address addr)
{
  NS_LOG_FUNCTION_NOARGS ();

  return SimulationSingleton<Ipv6AddressGeneratorImpl>::Get ()
         ->CheckAllocated (addr);
}

bool
Ipv6AddressGenerator::IsNetworkAllocated (const Ipv6Address addr, const Ipv6Prefix prefix)
{
  NS_LOG_FUNCTION_NOARGS ();

  return SimulationSingleton<Ipv6AddressGeneratorImpl>::Get ()
         ->IsNetworkAllocated (addr, prefix);
}

void
Ipv6AddressGenerator::TestMode (void)
{




  static bool AddAllocated (const Ipv6Address addr);

  /**
   * \brief Check the Ipv6Address allocation in the list of IPv6 entries
   *
   * \param addr The Ipv6Address to be checked in the list of Ipv4 entries
   * \returns true if the address is already allocated
   */
  static bool CheckAllocated (const Ipv6Address addr);

  /**
   * \brief Check if a network has already allocated addresses
   *
   * \param addr The Ipv6 network to be checked
   * \param prefix The Ipv6 network prefix
   * \returns true if the network is already allocated
   */
  static bool IsNetworkAllocated (const Ipv6Address addr, const Ipv6Prefix prefix);

  /**
   * \brief Used to turn off fatal errors and assertions, for testing
   */
  static void TestMode (void);

Return to bug 2834