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