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; }