bool PacketQueue::Enqueue (QueueEntry & entry) { NS_LOG_FUNCTION ("Enqueing packet destined for" << entry.GetIpv4Header ().GetDestination ()); Purge (); uint32_t numPacketswithdst; for (std::vector<QueueEntry>::const_iterator i = m_queue.begin (); i != m_queue.end (); ++i) { if ((i->GetPacket ()->GetUid () == entry.GetPacket ()->GetUid ()) && (i->GetIpv4Header ().GetDestination () == entry.GetIpv4Header ().GetDestination ())) { return false; } } numPacketswithdst = GetCountForPacketsWithDst (entry.GetIpv4Header ().GetDestination ()); NS_LOG_DEBUG ("Number of packets with this destination: " << numPacketswithdst); /** For Brock Paper comparision*/ if (numPacketswithdst >= m_maxLenPerDst || m_queue.size () >= m_maxLen) { NS_LOG_DEBUG ("Max packets reached for this destination. Not queuing any further packets"); return false; } else { // NS_LOG_DEBUG("Packet size while enqueing "<<entry.GetPacket()->GetSize()); entry.SetExpireTime (m_queueTimeout); m_queue.push_back (entry); return true; } }
void OneInterestRequester::SendInterest() { if (!m_isRunning) return; ///////////////////////////////////// // Sending one Interest packet out // ///////////////////////////////////// // Create and configure ndn::Interest auto interest = std::make_shared<ndn::Interest>(m_name); UniformVariable rand(0, std::numeric_limits<uint32_t>::max()); interest->setNonce(rand.GetValue()); interest->setInterestLifetime(ndn::time::seconds(1)); NS_LOG_DEBUG("Sending Interest packet for " << m_name); // Call trace (for logging purposes) m_transmittedInterests(interest, this, m_face); NS_LOG_DEBUG(">> I: " << m_name); // Forward packet to lower (network) layer m_face->onReceiveInterest(*interest); }
void UanChannel::TxPacket (Ptr<UanTransducer> src, Ptr<Packet> packet, double txPowerDb, UanTxMode txMode) { Ptr<MobilityModel> senderMobility = 0; NS_LOG_DEBUG ("Channel scheduling"); for (UanDeviceList::const_iterator i = m_devList.begin (); i != m_devList.end (); i++) { if (src == i->second) { senderMobility = i->first->GetNode ()->GetObject<MobilityModel> (); break; } } NS_ASSERT (senderMobility != 0); uint32_t j = 0; UanDeviceList::const_iterator i = m_devList.begin (); for (; i != m_devList.end (); i++) { if (src != i->second) { NS_LOG_DEBUG ("Scheduling " << i->first->GetMac ()->GetAddress ()); Ptr<MobilityModel> rcvrMobility = i->first->GetNode ()->GetObject<MobilityModel> (); Time delay = m_prop->GetDelay (senderMobility, rcvrMobility, txMode); UanPdp pdp = m_prop->GetPdp (senderMobility, rcvrMobility, txMode); double rxPowerDb = txPowerDb - m_prop->GetPathLossDb (senderMobility, rcvrMobility, txMode); NS_LOG_DEBUG ("txPowerDb=" << txPowerDb << "dB, rxPowerDb=" << rxPowerDb << "dB, distance=" << senderMobility->GetDistanceFrom (rcvrMobility) << "m, delay=" << delay); uint32_t dstNodeId = i->first->GetNode ()->GetId (); Ptr<Packet> copy = packet->Copy (); Simulator::ScheduleWithContext (dstNodeId, delay, &UanChannel::SendUp, this, j, copy, rxPowerDb, txMode, pdp); } j++; } }
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; }
// Callback that will be called when Data arrives void CustomApp1::OnData(std::shared_ptr<const ndn::Data> data) { NS_LOG_DEBUG("Receiving Data packet for " << data->getName()); std::cout<<"data dropped "<<std::endl; std::cout << "DATA received for name " << data->getName() << std::endl; }
/** * Neighborhood discovery */ void FceApplication::NeighborLost(std::string context, Ptr<const Packet> packet, Mac48Address addr){ // Find the nodeId that has been called size_t aux = context.find("/",10); std::string strIndex = context.substr(10,aux-10); // Convert the index to integer int index = atoi (strIndex.c_str()); // Get the node (my node) Ptr<Node> node = ns3::NodeList::GetNode(index); //Get the application Ptr <Application> app = node->GetApplication(0); Ptr<FceApplication> myApp = DynamicCast<FceApplication>(app); MacAddrMapIterator i = myApp->m_neighborList.find (addr); if (i == myApp->m_neighborList.end ()){ // update the beacon index NS_LOG_DEBUG("ERROR. Trying to delete an unexisting neighbor"); } else { myApp->m_neighborList.erase(i); } // MacAddrMapIterator i = m_neighborList.find (addr); // if (i == m_neighborList.end ()){ // // update the beacon index // NS_LOG_DEBUG("ERROR. Trying to delete an unexisting neighbor"); // } // else { // m_neighborList.erase(i); // } // if (vehicle.getId() == "0.5") { // std::cout << vehicle.getId() << "," << " lost a neighbor: " << addr << ", power: " << " number of neighbors: " << m_neighborList.size() << ", context: " << context << std::endl; // } }
void UanChannel::SendUp (uint32_t i, Ptr<Packet> packet, double rxPowerDb, UanTxMode txMode, UanPdp pdp) { NS_LOG_DEBUG ("Channel: In sendup"); m_devList[i].second->Receive (packet, rxPowerDb, txMode, pdp); }
Ipv4EndPoint * Ipv4EndPointDemux::Allocate (Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort) { NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) { if ((*i)->GetLocalPort () == localPort && (*i)->GetLocalAddress () == localAddress && (*i)->GetPeerPort () == peerPort && (*i)->GetPeerAddress () == peerAddress) { NS_LOG_WARN ("No way we can allocate this end-point."); /* no way we can allocate this end-point. */ return 0; } } Ipv4EndPoint *endPoint = new Ipv4EndPoint (localAddress, localPort); endPoint->SetPeer (peerAddress, peerPort); m_endPoints.push_back (endPoint); NS_LOG_DEBUG ("Now have >>" << m_endPoints.size () << "<< endpoints."); return endPoint; }
double LogDistancePropagationLossModel::DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b) const { double distance = a->GetDistanceFrom (b); if (distance <= m_referenceDistance) { return txPowerDbm; } /** * The formula is: * rx = 10 * log (Pr0(tx)) - n * 10 * log (d/d0) * * Pr0: rx power at reference distance d0 (W) * d0: reference distance: 1.0 (m) * d: distance (m) * tx: tx power (dB) * rx: dB * * Which, in our case is: * * rx = rx0(tx) - 10 * n * log (d/d0) */ double pathLossDb = 10 * m_exponent * std::log10 (distance / m_referenceDistance); double rxc = -m_referenceLoss - pathLossDb; NS_LOG_DEBUG ("distance="<<distance<<"m, reference-attenuation="<< -m_referenceLoss<<"dB, "<< "attenuation coefficient="<<rxc<<"db"); return txPowerDbm + rxc; }
void PacketProbe::ConnectByPath (std::string path) { NS_LOG_FUNCTION (this << path); NS_LOG_DEBUG ("Name of probe to search for in config database: " << path); Config::ConnectWithoutContext (path, MakeCallback (&ns3::PacketProbe::TraceSink, this)); }
WifiTxVector MinstrelWifiManager::DoGetRtsTxVector (WifiRemoteStation *st) { MinstrelWifiRemoteStation *station = (MinstrelWifiRemoteStation *) st; NS_LOG_DEBUG ("DoGetRtsMode m_txrate=" << station->m_txrate); return WifiTxVector (GetSupported (station, 0), GetDefaultTxPowerLevel (), GetShortRetryCount (station), GetShortGuardInterval (station), Min (GetNumberOfReceiveAntennas (station),GetNumberOfTransmitAntennas()), GetNumberOfTransmitAntennas (station), GetStbc (station)); }
bool PacketProbe::ConnectByObject (std::string traceSource, Ptr<Object> obj) { NS_LOG_FUNCTION (this << traceSource << obj); NS_LOG_DEBUG ("Name of probe (if any) in names database: " << Names::FindPath (obj)); bool connected = obj->TraceConnectWithoutContext (traceSource, MakeCallback (&ns3::PacketProbe::TraceSink, this)); return connected; }
void Hijacker::OnInterest(std::shared_ptr<const ndn::Interest> interest) { ndn::App::OnInterest(interest); // forward call to perform app-level tracing // do nothing else (hijack interest) NS_LOG_DEBUG("Do nothing for incoming interest for" << interest->getName()); }
void MinstrelWifiManager::DoReportRtsFailed (WifiRemoteStation *st) { MinstrelWifiRemoteStation *station = (MinstrelWifiRemoteStation *)st; NS_LOG_DEBUG ("DoReportRtsFailed m_txrate=" << station->m_txrate); station->m_shortRetry++; }
void StrategyChoiceHelper::Install(Ptr<Node> node, const Name& namePrefix, const Name& strategy) { ControlParameters parameters; parameters.setName(namePrefix); NS_LOG_DEBUG("Node ID: " << node->GetId() << " with forwarding strategy " << strategy); parameters.setStrategy(strategy); sendCommand(parameters, node); }
double RandomPropagationLossModel::DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b) const { double rxc = -m_variable->GetValue (); NS_LOG_DEBUG ("attenuation coefficent="<<rxc<<"Db"); return txPowerDbm + rxc; }
void DsrMainHelper::Install (DsrHelper &dsrHelper, NodeContainer nodes) { NS_LOG_DEBUG ("Passed node container"); delete m_dsrHelper; m_dsrHelper = dsrHelper.Copy (); for (NodeContainer::Iterator i = nodes.Begin (); i != nodes.End (); ++i) { Install (*i); } }
// Callback that will be called when Interest arrives void CustomApp1::OnInterest(std::shared_ptr<const ndn::Interest> interest) { ndn::App::OnInterest(interest); NS_LOG_DEBUG("Received Interest packet for " << interest->getName()); // Note that Interests send out by the app will not be sent back to the app ! Name sender("/malicious"); auto data = std::make_shared<ndn::Data>(interest->getName()); data->setFreshnessPeriod(ndn::time::milliseconds(1000)); data->setContent(std::make_shared< ::ndn::Buffer>(1024)); ndn::StackHelper::getKeyChain().sign(*data); NS_LOG_DEBUG("Sending Data packet for " << data->getName()); // Call trace (for logging purposes) m_transmittedDatas(data, this, m_face); m_face->onReceiveData(*data); }
double NakagamiPropagationLossModel::DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b) const { // select m parameter double distance = a->GetDistanceFrom (b); NS_ASSERT (distance >= 0); double m; if (distance < m_distance1) { m = m_m0; } else if (distance < m_distance2) { m = m_m1; } else { m = m_m2; } // the current power unit is dBm, but Watt is put into the Nakagami / // Rayleigh distribution. double powerW = std::pow (10, (txPowerDbm - 30) / 10); double resultPowerW; // switch between Erlang- and Gamma distributions: this is only for // speed. (Gamma is equal to Erlang for any positive integer m.) unsigned int int_m = static_cast<unsigned int>(std::floor (m)); if (int_m == m) { resultPowerW = m_erlangRandomVariable->GetValue (int_m, powerW / m); } else { resultPowerW = m_gammaRandomVariable->GetValue (m, powerW / m); } double resultPowerDbm = 10 * std::log10 (resultPowerW) + 30; NS_LOG_DEBUG ("Nakagami distance=" << distance << "m, " << "power=" << powerW <<"W, " << "resultPower=" << resultPowerW << "W=" << resultPowerDbm << "dBm"); return resultPowerDbm; }
shared_ptr<NetDeviceFace> StackHelper::PointToPointNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn, Ptr<NetDevice> device) const { NS_LOG_DEBUG("Creating point-to-point NetDeviceFace on node " << node->GetId()); shared_ptr<NetDeviceFace> face = std::make_shared<NetDeviceFace>(node, device); ndn->addFace(face); NS_LOG_LOGIC("Node " << node->GetId() << ": added NetDeviceFace as face #" << face->getLocalUri()); return face; }
Ipv4EndPoint * Ipv4EndPointDemux::Allocate (Ipv4Address address, uint16_t port) { NS_LOG_FUNCTION (this << address << port); if (LookupLocal (address, port)) { NS_LOG_WARN ("Duplicate address/port; failing."); return 0; } Ipv4EndPoint *endPoint = new Ipv4EndPoint (address, port); m_endPoints.push_back (endPoint); NS_LOG_DEBUG ("Now have >>" << m_endPoints.size () << "<< endpoints."); return endPoint; }
bool PacketQueue::Find (Ipv4Address dst) { for (std::vector<QueueEntry>::const_iterator i = m_queue.begin (); i != m_queue.end (); ++i) { if (i->GetIpv4Header ().GetDestination () == dst) { NS_LOG_DEBUG ("Find"); return true; } } return false; }
Ipv4EndPoint * Ipv4EndPointDemux::Allocate (Ipv4Address address) { NS_LOG_FUNCTION (this << address); uint16_t port = AllocateEphemeralPort (); if (port == 0) { NS_LOG_WARN ("Ephemeral port allocation failed."); return 0; } Ipv4EndPoint *endPoint = new Ipv4EndPoint (address, port); m_endPoints.push_back (endPoint); NS_LOG_DEBUG ("Now have >>" << m_endPoints.size () << "<< endpoints."); return endPoint; }
void VerifyingConsumer::OnData(shared_ptr<const Data> data) { if (!m_active) return; App::OnData(data); // tracing inside NS_LOG_FUNCTION(this << data); m_validator->validate(*data, bind(&VerifyingConsumer::ValidationPassed, this, _1), bind(&VerifyingConsumer::OnDataValidationFailed, this, _1, _2)); // NS_LOG_INFO ("Received content object: " << boost::cref(*data)); // This could be a problem...... uint32_t seq = data->getName().at(-1).toSequenceNumber(); NS_LOG_INFO("< DATA for " << seq); int hopCount = 0; auto ns3PacketTag = data->getTag<Ns3PacketTag>(); if (ns3PacketTag != nullptr) { // e.g., packet came from local node's cache FwHopCountTag hopCountTag; if (ns3PacketTag->getPacket()->PeekPacketTag(hopCountTag)) { hopCount = hopCountTag.Get(); NS_LOG_DEBUG("Hop count: " << hopCount); } } SeqTimeoutsContainer::iterator entry = m_seqLastDelay.find(seq); if (entry != m_seqLastDelay.end()) { m_lastRetransmittedInterestDataDelay(this, seq, Simulator::Now() - entry->time, hopCount); } entry = m_seqFullDelay.find(seq); if (entry != m_seqFullDelay.end()) { m_firstInterestDataDelay(this, seq, Simulator::Now() - entry->time, m_seqRetxCounts[seq], hopCount); } m_seqRetxCounts.erase(seq); m_seqFullDelay.erase(seq); m_seqLastDelay.erase(seq); m_seqTimeouts.erase(seq); m_retxSeqs.erase(seq); m_rtt->AckSeq(SequenceNumber32(seq)); }
void Consumer::WillSendOutInterest(uint32_t sequenceNumber) { NS_LOG_DEBUG("Trying to add " << sequenceNumber << " with " << Simulator::Now() << ". already " << m_seqTimeouts.size() << " items"); m_seqTimeouts.insert(SeqTimeout(sequenceNumber, Simulator::Now())); m_seqFullDelay.insert(SeqTimeout(sequenceNumber, Simulator::Now())); m_seqLastDelay.erase(sequenceNumber); m_seqLastDelay.insert(SeqTimeout(sequenceNumber, Simulator::Now())); m_seqRetxCounts[sequenceNumber]++; m_rtt->SentSeq(SequenceNumber32(sequenceNumber), 1); }
void PacketsScene::redraw (qreal fromTime, qreal toTime, QVector<uint32_t> allowedNodes, bool showGrid) { m_showGrid = showGrid; resetLines (); if (fromTime >= toTime) { NS_LOG_DEBUG ("From Time should be lesser than To Time"); return; } m_fromTime = fromTime; m_toTime = toTime; m_allowedNodes = allowedNodes; addPackets (); }
void StrategyChoiceHelper::sendCommand(const ControlParameters& parameters, Ptr<Node> node) { NS_LOG_DEBUG("Strategy choice command was initialized"); Block encodedParameters(parameters.wireEncode()); Name commandName("/localhost/nfd/strategy-choice"); commandName.append("set"); commandName.append(encodedParameters); shared_ptr<Interest> command(make_shared<Interest>(commandName)); StackHelper::getKeyChain().sign(*command); Ptr<L3Protocol> l3protocol = node->GetObject<L3Protocol>(); l3protocol->injectInterest(*command); }
void FibHelper::AddNextHop(const ControlParameters& parameters, Ptr<Node> node) { NS_LOG_DEBUG("Add Next Hop command was initialized"); Block encodedParameters(parameters.wireEncode()); Name commandName("/localhost/nfd/fib"); commandName.append("add-nexthop"); commandName.append(encodedParameters); shared_ptr<Interest> command(make_shared<Interest>(commandName)); StackHelper::getKeyChain().sign(*command); Ptr<L3Protocol> l3protocol = node->GetObject<L3Protocol>(); shared_ptr<nfd::FibManager> fibManager = l3protocol->getFibManager(); fibManager->onFibRequest(*command); }
void PacketQueue::Purge () { // NS_LOG_DEBUG("Purging Queue"); IsExpired pred; for (std::vector<QueueEntry>::iterator i = m_queue.begin (); i != m_queue.end (); ++i) { if (pred (*i)) { NS_LOG_DEBUG ("Dropping outdated Packets"); Drop (*i, "Drop outdated packet "); } } m_queue.erase (std::remove_if (m_queue.begin (), m_queue.end (), pred), m_queue.end ()); }
double FriisPropagationLossModel::DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b) const { /* * Friis free space equation: * where Pt, Gr, Gr and P are in Watt units * L is in meter units. * * P Gt * Gr * (lambda^2) * --- = --------------------- * Pt (4 * pi * d)^2 * L * * Gt: tx gain (unit-less) * Gr: rx gain (unit-less) * Pt: tx power (W) * d: distance (m) * L: system loss * lambda: wavelength (m) * * Here, we ignore tx and rx gain and the input and output values * are in dB or dBm: * * lambda^2 * rx = tx + 10 log10 (-------------------) * (4 * pi * d)^2 * L * * rx: rx power (dB) * tx: tx power (dB) * d: distance (m) * L: system loss (unit-less) * lambda: wavelength (m) */ double distance = a->GetDistanceFrom (b); if (distance <= m_minDistance) { return txPowerDbm; } double numerator = m_lambda * m_lambda; double denominator = 16 * PI * PI * distance * distance * m_systemLoss; double pr = 10 * std::log10 (numerator / denominator); NS_LOG_DEBUG ("distance="<<distance<<"m, attenuation coefficient="<<pr<<"dB"); return txPowerDbm + pr; }