void NdiscCache::Entry::StartDelayTimer ()
{
NS_LOG_FUNCTION_NOARGS ();
m_delayTimer.SetFunction (&NdiscCache::Entry::FunctionDelayTimeout, this);
m_delayTimer.SetDelay (Seconds (Icmpv6L4Protocol::DELAY_FIRST_PROBE_TIME));
m_delayTimer.Schedule ();
}
bool
FileConsumerCbr::SendPacket()
{
NS_LOG_FUNCTION_NOARGS();
bool okay = FileConsumer::SendPacket();
if (okay)
{
m_inFlight++;
}
if (m_packetsSent < m_fileStartWindow && m_fileSize == 1)
{
// fprintf(stderr, "Pre-requesting packet no %d\n", m_packetsSent);
// schedule next event
double rrr = m_rand->GetValue()*5.0 - 2.5; // randomize the send-time a little bit
ScheduleNextSendEvent((rrr + 1000.0) / (double)m_windowSize);
} else {
if (m_hasReceivedManifest && this->m_fileSize > 0)
{
if (AreAllSeqReceived())
{
NS_LOG_DEBUG("Done, triggering OnFileReceived...");
OnFileReceived(0, 0);
} else {
// schedule next event
double rrr = m_rand->GetValue()*5.0 - 2.5; // randomize the send-time a little bit
ScheduleNextSendEvent((rrr + 1000.0) / (double)m_windowSize);
}
}
}
return okay;
}
void NdiscCache::Entry::StartReachableTimer ()
{
NS_LOG_FUNCTION_NOARGS ();
m_reachableTimer.SetFunction (&NdiscCache::Entry::FunctionReachableTimeout, this);
m_reachableTimer.SetDelay (MilliSeconds (Icmpv6L4Protocol::REACHABLE_TIME));
m_reachableTimer.Schedule ();
}
void NdiscCache::Entry::StartRetransmitTimer ()
{
NS_LOG_FUNCTION_NOARGS ();
m_retransTimer.SetFunction (&NdiscCache::Entry::FunctionRetransmitTimeout, this);
m_retransTimer.SetDelay (MilliSeconds (Icmpv6L4Protocol::RETRANS_TIMER));
m_retransTimer.Schedule ();
}
void
BuildingListPriv::Delete (void)
{
NS_LOG_FUNCTION_NOARGS ();
Config::UnregisterRootNamespaceObject (Get ());
(*DoGet ()) = 0;
}
Ipv4InterfaceContainer
Ipv4AddressHelper::Assign (const NetDeviceContainer &c)
{
NS_LOG_FUNCTION_NOARGS ();
Ipv4InterfaceContainer retval;
for (uint32_t i = 0; i < c.GetN (); ++i) {
Ptr<NetDevice> device = c.Get (i);
Ptr<Node> node = device->GetNode ();
NS_ASSERT_MSG (node, "Ipv4AddressHelper::Assign(): NetDevice is not not associated "
"with any node -> fail");
Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
NS_ASSERT_MSG (ipv4, "Ipv4AddressHelper::Assign(): NetDevice is associated"
" with a node without IPv4 stack installed -> fail "
"(maybe need to use InternetStackHelper?)");
int32_t interface = ipv4->GetInterfaceForDevice (device);
if (interface == -1)
{
interface = ipv4->AddInterface (device);
}
NS_ASSERT_MSG (interface >= 0, "Ipv4AddressHelper::Assign(): "
"Interface index not found");
Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (NewAddress (), m_mask);
ipv4->AddAddress (interface, ipv4Addr);
ipv4->SetMetric (interface, 1);
ipv4->SetUp (interface);
retval.Add (ipv4, interface);
}
return retval;
}
Ping6::Ping6 ()
{
NS_LOG_FUNCTION_NOARGS ();
m_sent = 0;
m_socket = 0;
m_seq = 0;
m_sendEvent = EventId ();
}
Ipv4AddressHelper::Ipv4AddressHelper (
const Ipv4Address network,
const Ipv4Mask mask,
const Ipv4Address address)
{
NS_LOG_FUNCTION_NOARGS ();
SetBase (network, mask, address);
}
void NdiscCache::DoDispose ()
{
NS_LOG_FUNCTION_NOARGS ();
Flush ();
m_device = 0;
m_interface = 0;
Object::DoDispose ();
}
CsmaChannel::CsmaChannel ()
:
Channel ()
{
NS_LOG_FUNCTION_NOARGS ();
m_state = IDLE;
m_deviceList.clear ();
}
Ipv4Address
Ipv4AddressHelper::NewNetwork (void)
{
NS_LOG_FUNCTION_NOARGS ();
++m_network;
m_address = m_base;
return Ipv4Address (m_network << m_shift);
}
Consumer::Consumer()
: m_rand(CreateObject<UniformRandomVariable>())
, m_seq(0)
, m_seqMax(0) // don't request anything
{
NS_LOG_FUNCTION_NOARGS();
m_rtt = CreateObject<RttMeanDeviation>();
}
void
App::DoDispose(void)
{
NS_LOG_FUNCTION_NOARGS();
// Unfortunately, this causes SEGFAULT
// The best reason I see is that apps are freed after ndn stack is removed
// StopApplication ();
Application::DoDispose();
}
// Application Methods
void
Consumer::StartApplication() // Called at time specified by Start
{
NS_LOG_FUNCTION_NOARGS();
// do base stuff
App::StartApplication();
ScheduleNextPacket();
}
VerifyingConsumer::VerifyingConsumer()
: m_rand(CreateObject<UniformRandomVariable>())
, m_seq(0)
, m_seqMax(0) // don't request anything
{
NS_LOG_FUNCTION_NOARGS();
m_rtt = CreateObject<RttMeanDeviation>();
m_validator = make_shared<::ndn::ValidatorConfig>();
m_validator->load("/Users/cwood/Projects/ndnSIM/onpath/validation-config.conf");
}
void
Consumer::StopApplication() // Called at time specified by Stop
{
NS_LOG_FUNCTION_NOARGS();
// cancel periodic packet generation
Simulator::Cancel(m_sendEvent);
// cleanup base stuff
App::StopApplication();
}
void Ping6::StopApplication ()
{
NS_LOG_FUNCTION_NOARGS ();
if (m_socket)
{
m_socket->SetRecvCallback (MakeNullCallback<void, Ptr<Socket> >());
}
Simulator::Cancel (m_sendEvent);
}
void NdiscCache::Flush ()
{
NS_LOG_FUNCTION_NOARGS ();
for (CacheI i = m_ndCache.begin (); i != m_ndCache.end (); i++)
{
delete (*i).second; /* delete the pointer NdiscCache::Entry */
}
m_ndCache.erase (m_ndCache.begin (), m_ndCache.end ());
}
void
App::StopApplication() // Called at time specified by Stop
{
NS_LOG_FUNCTION_NOARGS();
if (!m_active)
return; // don't assert here, just return
m_active = false;
m_face->close();
}
NdiscCache::Entry::Entry (NdiscCache* nd)
: m_ndCache (nd),
m_waiting (),
m_router (false),
m_reachableTimer (Timer::CANCEL_ON_DESTROY),
m_retransTimer (Timer::CANCEL_ON_DESTROY),
m_probeTimer (Timer::CANCEL_ON_DESTROY),
m_delayTimer (Timer::CANCEL_ON_DESTROY),
m_lastReachabilityConfirmation (Seconds (0.0)),
m_nsRetransmit (0)
{
NS_LOG_FUNCTION_NOARGS ();
}
void
BuildingListPriv::DoDispose (void)
{
NS_LOG_FUNCTION_NOARGS ();
for (std::vector<Ptr<Building> >::iterator i = m_buildings.begin ();
i != m_buildings.end (); i++)
{
Ptr<Building> building = *i;
building->Dispose ();
*i = 0;
}
m_buildings.erase (m_buildings.begin (), m_buildings.end ());
Object::DoDispose ();
}
void NdiscCache::Remove (NdiscCache::Entry* entry)
{
NS_LOG_FUNCTION_NOARGS ();
for (CacheI i = m_ndCache.begin (); i != m_ndCache.end (); i++)
{
if ((*i).second == entry)
{
m_ndCache.erase (i);
entry->ClearWaitingPacket ();
delete entry;
return;
}
}
}
void
Consumer::SendPacket()
{
if (!m_active)
return;
NS_LOG_FUNCTION_NOARGS();
uint32_t seq = std::numeric_limits<uint32_t>::max(); // invalid
while (m_retxSeqs.size()) {
seq = *m_retxSeqs.begin();
m_retxSeqs.erase(m_retxSeqs.begin());
break;
}
if (seq == std::numeric_limits<uint32_t>::max()) {
if (m_seqMax != std::numeric_limits<uint32_t>::max()) {
if (m_seq >= m_seqMax) {
return; // we are totally done
}
}
seq = m_seq++;
}
//
shared_ptr<Name> nameWithSequence = make_shared<Name>(m_interestName);
nameWithSequence->appendSequenceNumber(seq);
//
// shared_ptr<Interest> interest = make_shared<Interest> ();
shared_ptr<Interest> interest = make_shared<Interest>();
interest->setNonce(m_rand->GetValue(0, std::numeric_limits<uint32_t>::max()));
interest->setName(*nameWithSequence);
time::milliseconds interestLifeTime(m_interestLifeTime.GetMilliSeconds());
interest->setInterestLifetime(interestLifeTime);
// NS_LOG_INFO ("Requesting Interest: \n" << *interest);
NS_LOG_INFO("> Interest for " << seq);
WillSendOutInterest(seq);
m_transmittedInterests(interest, this, m_face);
m_face->onReceiveInterest(*interest);
ScheduleNextPacket();
}
Ipv4AddressHelper::Ipv4AddressHelper ()
{
NS_LOG_FUNCTION_NOARGS ();
//
// Set the default values to an illegal state. Do this so the client is
// forced to think at least briefly about what addresses get used and what
// is going on here.
//
m_network = 0xffffffff;
m_mask = 0;
m_address = 0xffffffff;
m_base = 0xffffffff;
m_shift = 0xffffffff;
m_max = 0xffffffff;
}
// Application Methods
void
App::StartApplication() // Called at time specified by Start
{
NS_LOG_FUNCTION_NOARGS();
NS_ASSERT(m_active != true);
m_active = true;
NS_ASSERT_MSG(GetNode()->GetObject<L3Protocol>() != 0,
"Ndn stack should be installed on the node " << GetNode());
// step 1. Create a face
m_face = std::make_shared<AppFace>(this);
// step 2. Add face to the Ndn stack
GetNode()->GetObject<L3Protocol>()->addFace(m_face);
}
uint32_t
Ipv4AddressHelper::NumAddressBits (uint32_t maskbits) const
{
NS_LOG_FUNCTION_NOARGS ();
for (uint32_t i = 0; i < N_BITS; ++i)
{
if (maskbits & 1)
{
NS_LOG_LOGIC ("NumAddressBits -> " << i);
return i;
}
maskbits >>= 1;
}
NS_ASSERT_MSG (false, "Ipv4AddressHelper::NumAddressBits(): Bad Mask");
return 0;
}
void NdiscCache::Entry::FunctionRetransmitTimeout ()
{
NS_LOG_FUNCTION_NOARGS ();
Ptr<Icmpv6L4Protocol> icmpv6 = m_ndCache->GetDevice ()->GetNode ()->GetObject<Ipv6L3Protocol> ()->GetIcmpv6 ();
Ipv6Address addr;
/* determine source address */
if (m_ipv6Address.IsLinkLocal ())
{
addr = m_ndCache->GetInterface ()->GetLinkLocalAddress ().GetAddress ();;
}
else if (!m_ipv6Address.IsAny ())
{
addr = m_ndCache->GetInterface ()->GetAddressMatchingDestination (m_ipv6Address).GetAddress ();
if (addr.IsAny ()) /* maybe address has expired */
{
/* delete the entry */
m_ndCache->Remove (this);
return;
}
}
if (GetNSRetransmit () < icmpv6->MAX_MULTICAST_SOLICIT)
{
IncNSRetransmit ();
icmpv6->SendNS (addr, Ipv6Address::MakeSolicitedAddress (m_ipv6Address), m_ipv6Address, m_ndCache->GetDevice ()->GetAddress ());
/* arm the timer again */
StartRetransmitTimer ();
}
else
{
Ptr<Packet> malformedPacket = m_waiting.front ();
if (malformedPacket == 0)
{
malformedPacket = Create<Packet> ();
}
icmpv6->SendErrorDestinationUnreachable (malformedPacket, addr, Icmpv6Header::ICMPV6_ADDR_UNREACHABLE);
/* delete the entry */
m_ndCache->Remove (this);
}
}
void NdiscCache::Entry::FunctionProbeTimeout ()
{
NS_LOG_FUNCTION_NOARGS ();
Ptr<Ipv6L3Protocol> ipv6 = m_ndCache->GetDevice ()->GetNode ()->GetObject<Ipv6L3Protocol> ();
Ptr<Icmpv6L4Protocol> icmpv6 = ipv6->GetIcmpv6 ();
if (GetNSRetransmit () < icmpv6->MAX_UNICAST_SOLICIT)
{
Ipv6Address addr;
if (m_ipv6Address.IsLinkLocal ())
{
addr = m_ndCache->GetInterface ()->GetLinkLocalAddress ().GetAddress ();
}
else if (!m_ipv6Address.IsAny ())
{
addr = m_ndCache->GetInterface ()->GetAddressMatchingDestination (m_ipv6Address).GetAddress ();
if (addr.IsAny ()) /* maybe address has expired */
{
/* delete the entry */
m_ndCache->Remove (this);
return;
}
}
else
{
/* should not happen */
return;
}
IncNSRetransmit ();
/* icmpv6->SendNS (m_ndCache->GetInterface ()->GetLinkLocalAddress (), m_ipv6Address, m_ipv6Address, m_ndCache->GetDevice ()->GetAddress ()); */
Ptr<Packet> p = icmpv6->ForgeNS (addr, m_ipv6Address, m_ipv6Address, m_ndCache->GetDevice ()->GetAddress ());
m_ndCache->GetDevice ()->Send (p, this->GetMacAddress (), Ipv6L3Protocol::PROT_NUMBER);
/* arm the timer again */
StartProbeTimer ();
}
else
{
/* delete the entry */
m_ndCache->Remove (this);
}
}
void Ping6::StartApplication ()
{
NS_LOG_FUNCTION_NOARGS ();
if (!m_socket)
{
TypeId tid = TypeId::LookupByName ("ns3::Ipv6RawSocketFactory");
m_socket = Socket::CreateSocket (GetNode (), tid);
NS_ASSERT (m_socket);
m_socket->Bind (Inet6SocketAddress (m_localAddress, 0));
m_socket->Connect (Inet6SocketAddress (m_peerAddress, 0));
m_socket->SetAttribute ("Protocol", UintegerValue (Ipv6Header::IPV6_ICMPV6));
m_socket->SetRecvCallback (MakeCallback (&Ping6::HandleRead, this));
}
ScheduleTransmit (Seconds (0.));
}
Socket::Socket (void)
: m_manualIpTos (false),
m_manualIpTtl (false),
m_ipRecvTos (false),
m_ipRecvTtl (false),
m_manualIpv6Tclass (false),
m_manualIpv6HopLimit (false),
m_ipv6RecvTclass (false),
m_ipv6RecvHopLimit (false)
{
NS_LOG_FUNCTION_NOARGS ();
m_boundnetdevice = 0;
m_recvPktInfo = false;
m_ipTos = 0;
m_ipTtl = 0;
m_ipv6Tclass = 0;
m_ipv6HopLimit = 0;
}
