tomh/ns-3-dev-spectrum-wifi: comparison src/dsr/model/dsr-routing.cc

equal deleted inserted replaced

-:78bf735a3d5e
+:9a34e618f40b
 Ipv4Address loopback ("127.0.0.1");
 for (uint32_t i = 0; i < m_ipv4->GetNInterfaces (); i++)
 {
 // Use primary address, if multiple
 Ipv4Address addr = m_ipv4->GetAddress (i, 0).GetLocal ();
-m_broadcast = m_ipv4->GetAddress (i, 0).GetBroadcast();
+m_broadcast = m_ipv4->GetAddress (i, 0).GetBroadcast ();
 NS_LOG_DEBUG ("The addr " << addr);
 if (addr != loopback)
 {
 m_mainAddress = addr;
 NS_LOG_DEBUG ("The node Address " << m_mainAddress);
 mac->TraceConnectWithoutContext ("TxErrHeader", routeCache->GetTxErrorCallback ());
 routeCache->AddArpCache (m_ipv4->GetInterface (i)->GetArpCache ());
 break;
 }
 }
-NS_ASSERT (m_mainAddress != Ipv4Address () && m_broadcast != Ipv4Address());
+NS_ASSERT (m_mainAddress != Ipv4Address () && m_broadcast != Ipv4Address ());
 }
 NS_LOG_DEBUG ("The number queues " << m_numPriorityQueues);
 for (uint32_t i = 0; i < m_numPriorityQueues; i++)
 {
 // Set the network queue max size and the delay
-NS_LOG_DEBUG ("The network size " << m_maxNetworkSize << " and the network delay " << m_maxNetworkDelay.GetSeconds());
+NS_LOG_DEBUG ("The network size " << m_maxNetworkSize << " and the network delay " << m_maxNetworkDelay.GetSeconds ());
 Ptr<dsr::DsrNetworkQueue> queue_i = CreateObject<dsr::DsrNetworkQueue> (m_maxNetworkSize,m_maxNetworkDelay);
 std::pair<std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator, bool> result_i = m_priorityQueue.insert (std::make_pair (i, queue_i));
 NS_ASSERT_MSG (result_i.second, "Error in creating queues");
 }
 Ptr<dsr::RreqTable> rreqTable = CreateObject<dsr::RreqTable> ();
 // Set the initial hop limit
 rreqTable->SetInitHopLimit (m_discoveryHopLimit);
 // Configure the request table parameters
 rreqTable->SetRreqTableSize (m_requestTableSize);
 {
 Ptr<Node> node = NodeList::GetNode (i);
 Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
 if (ipv4->GetAddress (1, 0).GetLocal () == address)
 {
-return uint16_t(i);
+return uint16_t (i);
 }
 }
 return 256;
 }
 uint8_t length = (sourceRoute.GetLength () + newUnreach.GetLength ());
 dsrRoutingHeader.SetNextHeader (protocol);
 dsrRoutingHeader.SetMessageType (1);
 dsrRoutingHeader.SetSourceId (GetIDfromIP (m_mainAddress));
 dsrRoutingHeader.SetDestId (255);
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 4);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 4);
 dsrRoutingHeader.AddDsrOption (newUnreach);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 Ptr<Packet> newPacket = Create<Packet> ();
 newPacket->AddHeader (dsrRoutingHeader); // Add the routing header with rerr and sourceRoute attached to it
 m_ipv4Route->SetOutputDevice (dev);
 uint32_t priority = GetPriority (DSR_CONTROL_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 sourceRoute.SetNodesAddress (nodeList); // Save the whole route in the source route header of the packet
 sourceRoute.SetSegmentsLeft ((nodeList.size () - 2)); // The segmentsLeft field will indicate the hops to go
 sourceRoute.SetSalvage (salvage);
 uint8_t length = sourceRoute.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 cleanP->AddHeader (dsrRoutingHeader);
 // Send the data packet out before schedule the next packet transmission
 SendPacket (cleanP, m_mainAddress, nextHop, protocol);
 Ptr<const Packet> mtP = cleanP->Copy ();
 // Put the data packet in the maintenance queue for data packet retransmission
 MaintainBuffEntry newEntry (/*Packet=*/ mtP, /*Ipv4Address=*/ m_mainAddress, /*nextHop=*/ nextHop,
 /*source=*/ m_mainAddress, /*destination=*/ destination, /*ackId=*/ 0,
-/*SegsLeft=*/nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
+/*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
 bool result = m_maintainBuffer.Enqueue (newEntry); // Enqueue the packet the the maintenance buffer
 if (result)
 {
 NetworkKey networkKey;
 networkKey.m_ackId = newEntry.GetAckId ();
 }
 sourceRoute.SetSegmentsLeft ((nodeList.size () - 2));     // The segmentsLeft field will indicate the hops to go
 sourceRoute.SetSalvage (salvage);
 uint8_t length = sourceRoute.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 cleanP->AddHeader (dsrRoutingHeader);
 // Send the data packet out before schedule the next packet transmission
 SendPacket (cleanP, source, nextHop, protocol);
 Ptr<const Packet> mtP = cleanP->Copy ();
 SetRoute (nextHop, m_mainAddress);
 // Put the data packet in the maintenance queue for data packet retransmission
 MaintainBuffEntry newEntry (/*Packet=*/ mtP, /*Ipv4Address=*/ m_mainAddress, /*nextHop=*/ nextHop,
 /*source=*/ source, /*destination=*/ destination, /*ackId=*/ 0,
-/*SegsLeft=*/nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
+/*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
 bool result = m_maintainBuffer.Enqueue (newEntry);     // Enqueue the packet the the maintenance buffer
 if (result)
 {
 NetworkKey networkKey;
 }
 sourceRoute.SetSegmentsLeft ((nodeList.size () - 2));
 uint8_t srLength = sourceRoute.GetLength ();
 uint8_t length = (srLength + rerrLength);
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 4);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 4);
 dsrRoutingHeader.AddDsrOption (rerrUnreachHeader);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 newPacket->AddHeader (dsrRoutingHeader);
 SetRoute (nextHop, m_mainAddress);
 Ptr<NetDevice> dev = m_ip->GetNetDevice (m_ip->GetInterfaceForAddress (m_mainAddress));
 m_ipv4Route->SetOutputDevice (dev);
-NS_LOG_INFO ("Send the packet to the next hop address " << nextHop << " from " << m_mainAddress << " with the size " << newPacket->GetSize());
+NS_LOG_INFO ("Send the packet to the next hop address " << nextHop << " from " << m_mainAddress << " with the size " << newPacket->GetSize ());
 uint32_t priority = GetPriority (DSR_CONTROL_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 dsrRoutingHeader.SetMessageType (1);
 dsrRoutingHeader.SetSourceId (GetIDfromIP (rerr.GetErrorSrc ()));
 dsrRoutingHeader.SetDestId (GetIDfromIP (rerr.GetErrorDst ()));
 uint8_t length = (sourceRoute.GetLength () + rerr.GetLength ());
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 4);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 4);
 dsrRoutingHeader.AddDsrOption (rerr);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 Ptr<Packet> packet = Create<Packet> ();
 packet->AddHeader (dsrRoutingHeader);
 Ptr<NetDevice> dev = m_ip->GetNetDevice (m_ip->GetInterfaceForAddress (m_mainAddress));
 route->SetOutputDevice (dev);
 uint32_t priority = GetPriority (DSR_CONTROL_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (packet, m_mainAddress, nextHop, Simulator::Now (), route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 Scheduler (priority);
 }
 sourceRoute.SetSegmentsLeft ((nodeList.size () - 2));       // The segmentsLeft field will indicate the hops to go
 sourceRoute.SetSalvage (salvage);
 uint8_t length = sourceRoute.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 cleanP->AddHeader (dsrRoutingHeader);
 // Send the data packet out before schedule the next packet transmission
 SendPacket (cleanP, source, nextHop, protocol);
 Ptr<const Packet> mtP = cleanP->Copy ();
-NS_LOG_DEBUG ("maintain packet size " << cleanP->GetSize());
+NS_LOG_DEBUG ("maintain packet size " << cleanP->GetSize ());
 // Put the data packet in the maintenance queue for data packet retransmission
 MaintainBuffEntry newEntry (/*Packet=*/ mtP, /*ourAddress=*/ m_mainAddress, /*nextHop=*/ nextHop,
 /*source=*/ source, /*destination=*/ destination, /*ackId=*/ 0,
-/*SegsLeft=*/nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
+/*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
 bool result = m_maintainBuffer.Enqueue (newEntry);       // Enqueue the packet the the maintenance buffer
 if (result)
 {
 NetworkKey networkKey;
 networkKey.m_ackId = newEntry.GetAckId ();
 m_ipv4Route->SetOutputDevice (dev);
 uint32_t priority = GetPriority (DSR_DATA_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (packet, source, nextHop, Simulator::Now (), m_ipv4Route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 {
 numPriorities = priority;
 }
 // priorities range from 0 to m_numPriorityQueues, with 0 as the highest priority
 for (uint32_t i = priority; numPriorities < m_numPriorityQueues; numPriorities++)
 {
 std::map<uint32_t, Ptr<DsrNetworkQueue> >::iterator q = m_priorityQueue.find (i);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = q->second;
 uint32_t queueSize = dsrNetworkQueue->GetSize ();
 if (queueSize == 0)
 {
 if ((i == (m_numPriorityQueues - 1)) && continueWithFirst)
 {
 i = 0;
 }
+else
+{
+i++;
+}
+}
 else
 {
-i++;
+uint32_t totalQueueSize;
-}
+for (std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator j = m_priorityQueue.begin (); j != m_priorityQueue.end (); j++)
-}
+{
-else
+NS_LOG_DEBUG ("The size of the network queue for " << j->first << " is " << j->second->GetSize ());
-{
+totalQueueSize += j->second->GetSize ();
-uint32_t totalQueueSize;
+NS_LOG_DEBUG ("And the total size is " << totalQueueSize);
-for (std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator j = m_priorityQueue.begin (); j != m_priorityQueue.end (); j++)
+}
-{
+if (totalQueueSize > 5)
-NS_LOG_DEBUG ("The size of the network queue for " << j->first << " is " << j->second->GetSize());
+{
-totalQueueSize += j->second->GetSize ();
+// Here the queue size is larger than 5, we need to increase the retransmission timer for each packet in the network queue
-NS_LOG_DEBUG ("And the total size is " << totalQueueSize);
+IncreaseRetransTimer ();
 }
-if (totalQueueSize > 5)
+DsrNetworkQueueEntry newEntry;
-{
+dsrNetworkQueue->Dequeue (newEntry);
-// Here the queue size is larger than 5, we need to increase the retransmission timer for each packet in the network queue
+if (SendRealDown (newEntry))
-IncreaseRetransTimer ();
+{
-}
+NS_LOG_DEBUG ("Packet sent by Dsr. Calling PriorityScheduler after some time");
-DsrNetworkQueueEntry newEntry;
+//packet was successfully sent down. call scheduler after some time
-dsrNetworkQueue->Dequeue (newEntry);
+Simulator::Schedule (MicroSeconds (UniformVariable ().GetInteger (0, 1000)),
-if (SendRealDown (newEntry))
+&DsrRouting::PriorityScheduler,this, i, false);
-{
+}
-NS_LOG_DEBUG("Packet sent by Dsr. Calling PriorityScheduler after some time");
+else
-//packet was successfully sent down. call scheduler after some time
+{
-Simulator::Schedule (MicroSeconds (UniformVariable ().GetInteger (0, 1000)),
+// packet was dropped by Dsr. Call scheduler immediately so that we can
-&DsrRouting::PriorityScheduler,this, i, false);
+// send another packet immediately.
-}
+NS_LOG_DEBUG ("Packet dropped by Dsr. Calling PriorityScheduler immediately");
-else
+Simulator::Schedule (Seconds (0), &DsrRouting::PriorityScheduler, this, i, false);
-{
+}
-// packet was dropped by Dsr. Call scheduler immediately so that we can
+if ((i == (m_numPriorityQueues - 1)) && continueWithFirst)
-// send another packet immediately.
+{
-NS_LOG_DEBUG("Packet dropped by Dsr. Calling PriorityScheduler immediately");
+i = 0;
-Simulator::Schedule (Seconds (0), &DsrRouting::PriorityScheduler, this, i, false);
+}
-}
+else
-if ((i == (m_numPriorityQueues - 1)) && continueWithFirst)
+{
-{
+i++;
-i = 0;
+}
 }
-else
+}
-{
-i++;
-}
-}
-}
 }
 void
 DsrRouting::IncreaseRetransTimer ()
 {
 Ipv4Address nextHop = i->GetNextHopAddress ();
 for (std::map<NetworkKey, Timer>::iterator j = m_addressForwardTimer.begin (); j != m_addressForwardTimer.end (); j++)
 {
 if (nextHop == j->first.m_nextHop)
 {
-NS_LOG_DEBUG ("The network delay left is " << j->second.GetDelayLeft());
+NS_LOG_DEBUG ("The network delay left is " << j->second.GetDelayLeft ());
 j->second.SetDelay (j->second.GetDelayLeft () + m_retransIncr);
 NS_LOG_DEBUG ("The new network delay time is " << j->second.GetDelayLeft ());
 }
 }
 }
 NS_LOG_FUNCTION (this);
 Ipv4Address source = newEntry.GetSourceAddress ();
 Ipv4Address nextHop = newEntry.GetNextHopAddress ();
 Ptr<Packet> packet = newEntry.GetPacket ()->Copy ();
 Ptr<Ipv4Route> route = newEntry.GetIpv4Route ();
-m_downTarget (packet, source, nextHop, GetProtocolNumber(), route);
+m_downTarget (packet, source, nextHop, GetProtocolNumber (), route);
 return true;
 }
 void
 DsrRouting::SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute, Ipv4Address nextHop, uint8_t protocol)
 dsrRoutingHeader.SetMessageType (2);
 dsrRoutingHeader.SetSourceId (GetIDfromIP (source));
 dsrRoutingHeader.SetDestId (GetIDfromIP (destination));
 uint8_t length = sourceRoute.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 p->AddHeader (dsrRoutingHeader);
 // Send the data packet out before schedule the next packet transmission
 NS_LOG_DEBUG ("Send out the data packet");
 Ptr<const Packet> mtP = p->Copy ();
 // Put the data packet in the maintenance queue for data packet retransmission
 MaintainBuffEntry newEntry (/*Packet=*/ mtP, /*ourAddress=*/ m_mainAddress, /*nextHop=*/ nextHop,
 /*source=*/ source, /*destination=*/ destination, /*ackId=*/ 0,
-/*SegsLeft=*/nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
+/*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
 bool result = m_maintainBuffer.Enqueue (newEntry);       // Enqueue the packet the the maintenance buffer
 if (result)
 {
 NetworkKey networkKey;
 DsrRoutingHeader newRoutingHeader;
 newRoutingHeader.SetNextHeader (protocol);
 newRoutingHeader.SetMessageType (1);
 newRoutingHeader.SetSourceId (GetIDfromIP (rerr.GetErrorSrc ()));
 newRoutingHeader.SetDestId (GetIDfromIP (rerr.GetErrorDst ()));
-newRoutingHeader.SetPayloadLength (uint16_t(length) + 4);
+newRoutingHeader.SetPayloadLength (uint16_t (length) + 4);
 newRoutingHeader.AddDsrOption (newUnreach);
 newRoutingHeader.AddDsrOption (sourceRoute);
 if (m_routeCache->IsLinkCache ())
 {
 m_routeCache->UseExtends (nodeList);
 m_ipv4Route->SetOutputDevice (dev);
 uint32_t priority = GetPriority (DSR_CONTROL_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 NS_LOG_INFO ("Packet dropped as dsr network queue is full");
 }
 }
 }
 if (m_errorBuffer.GetSize () != 0 && m_errorBuffer.Find (destination))
 {
 NS_LOG_DEBUG ("Schedule sending the next packet in send buffer");
 Simulator::Schedule (MilliSeconds (UniformVariable ().GetInteger (0,100)),
 &DsrRouting::SendPacketFromBuffer,this,sourceRoute,nextHop,protocol);
 }
 }
 }
 else
 {
 NS_LOG_DEBUG ("Packet not found in either the send or error buffer");
 * Create a packet to fill maintenance buffer, not used to compare
 * The reason is ack header doesn't have the original packet copy
 */
 Ptr<Packet> mainP = Create<Packet> ();
 MaintainBuffEntry newEntry (/*Packet=*/ mainP, /*ourAddress=*/ sender, /*nextHop=*/ receiver,
 /*source=*/ realSrc, /*destination=*/ realDst, /*ackId=*/ ackId,
-/*SegsLeft=*/0, /*expire time=*/ Simulator::Now ());
+/*SegsLeft=*/ 0, /*expire time=*/ Simulator::Now ());
 CancelNetworkPacketTimer (newEntry);
 }
 void
 DsrRouting::CancelNetworkPacketTimer (MaintainBuffEntry & mb)
 m_addressForwardCnt.erase (networkKey);
 NS_LOG_INFO ("ackId " << mb.GetAckId () << " ourAdd " << mb.GetOurAdd () << " nextHop " << mb.GetNextHop ()
 << " source " << mb.GetSrc () << " destination " << mb.GetDst ()
 << " segsLeft " << (uint32_t)mb.GetSegsLeft ()
 );
 // Find the network acknowledgment timer
 std::map<NetworkKey, Timer>::const_iterator i =
 m_addressForwardTimer.find (networkKey);
 if (i == m_addressForwardTimer.end ())
 {
 NS_LOG_INFO ("did not find the packet timer");
 }
 else
 {
 NS_LOG_INFO ("Timer not canceled");
 }
 m_addressForwardTimer.erase (networkKey);
 }
 // Erase the maintenance entry
 // yet this does not check the segments left value here
 if (m_maintainBuffer.NetworkEqual (mb))
 {
 NS_LOG_INFO ("Remove same maintenance buffer entry based on network acknowledgment");
 }
 }
 void
 DsrRouting::CancelPassivePacketTimer (MaintainBuffEntry & mb)
 {
 m_passiveCnt[passiveKey] = 0;
 m_passiveCnt.erase (passiveKey);
 // Find the passive acknowledgment timer
 std::map<PassiveKey, Timer>::const_iterator j =
 m_passiveAckTimer.find (passiveKey);
 if (j == m_passiveAckTimer.end ())
 {
 NS_LOG_INFO ("did not find the passive timer");
 }
 else
 }
 uint8_t length = (sourceRoute.GetLength () + ackReq.GetLength ());
 NS_LOG_INFO ("length of source route header " << (uint32_t)(sourceRoute.GetLength ())
 << " length of ack request header " << (uint32_t)(ackReq.GetLength ()));
-newDsrRoutingHeader.SetPayloadLength (uint16_t(length) + 4);
+newDsrRoutingHeader.SetPayloadLength (uint16_t (length) + 4);
 newDsrRoutingHeader.AddDsrOption (sourceRoute);
 newDsrRoutingHeader.AddDsrOption (ackReq);
 p->AddHeader (newDsrRoutingHeader);
 SetRoute (nextHop, m_mainAddress);
 // Send out the data packet
 uint32_t priority = GetPriority (DSR_DATA_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (p, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 // After m_tryPassiveAcks, schedule the packet retransmission using network acknowledgment option
 m_addressForwardTimer[networkKey].SetFunction (&DsrRouting::NetworkScheduleTimerExpire, this);
 m_addressForwardTimer[networkKey].Remove ();
 m_addressForwardTimer[networkKey].SetArguments (newEntry, protocol);
-NS_LOG_DEBUG ("The packet retries time for " << newEntry.GetAckId() << " is " << m_sendRetries
+NS_LOG_DEBUG ("The packet retries time for " << newEntry.GetAckId () << " is " << m_sendRetries
 << " and the delay time is " << Time (2 * m_nodeTraversalTime));
 // Back-off mechanism
 m_addressForwardTimer[networkKey].Schedule (Time (2 * m_nodeTraversalTime));
 }
 else
 {
 NS_LOG_DEBUG ("The packet retry we have done " << m_sendRetries);
 p = mb.GetPacket ()->Copy ();
 dsrP = mb.GetPacket ()->Copy ();
-NS_LOG_DEBUG ("The packet with dsr header " << dsrP->GetSize());
+NS_LOG_DEBUG ("The packet with dsr header " << dsrP->GetSize ());
 networkKey.m_ackId = mb.GetAckId ();
 networkKey.m_ourAdd = mb.GetOurAdd ();
 networkKey.m_nextHop = mb.GetNextHop ();
 networkKey.m_source = mb.GetSrc ();
 networkKey.m_destination = mb.GetDst ();
 // After m_tryPassiveAcks, schedule the packet retransmission using network acknowledgment option
 m_addressForwardTimer[networkKey].SetFunction (&DsrRouting::NetworkScheduleTimerExpire, this);
 m_addressForwardTimer[networkKey].Remove ();
 m_addressForwardTimer[networkKey].SetArguments (mb, protocol);
-NS_LOG_DEBUG ("The packet retries time for " << mb.GetAckId() << " is " << m_sendRetries
+NS_LOG_DEBUG ("The packet retries time for " << mb.GetAckId () << " is " << m_sendRetries
 << " and the delay time is " << Time (2 * m_sendRetries *  m_nodeTraversalTime));
 // Back-off mechanism
 m_addressForwardTimer[networkKey].Schedule (Time (2 * m_sendRetries * m_nodeTraversalTime));
 }
 }
 dsrRoutingHeader.SetDestId (GetIDfromIP (targetAddress));
 // We get the salvage value in sourceRoute header and set it to route error header if triggered error
 Ptr<Packet> p = packet->Copy ();
 uint8_t length = sourceRoute.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 dsrRoutingHeader.AddDsrOption (sourceRoute);
 p->AddHeader (dsrRoutingHeader);
 // Send the data packet out before schedule the next packet transmission
 SendPacket (p, source, nextHop, protocol);
 Ptr<const Packet> mtP = p->Copy ();
 MaintainBuffEntry newEntry (/*Packet=*/ mtP, /*ourAddress=*/ m_mainAddress, /*nextHop=*/ nextHop,
 /*source=*/ source, /*destination=*/ targetAddress,
-/*ackId=*/ m_ackId, /*SegsLeft=*/sourceRoute.GetSegmentsLeft(), /*expire time=*/ m_maxMaintainTime);
+/*ackId=*/ m_ackId, /*SegsLeft=*/ sourceRoute.GetSegmentsLeft (), /*expire time=*/ m_maxMaintainTime);
 bool result = m_maintainBuffer.Enqueue (newEntry);
 if (result)
 {
 NetworkKey networkKey;
 m_requestId = m_rreqTable->CheckUniqueRreqId (destination);      // Check the Id cache for duplicate ones
 rreqHeader.SetId (m_requestId);
 dsrRoutingHeader.AddDsrOption (rreqHeader);                      // Add the rreqHeader to the dsr extension header
 uint8_t length = rreqHeader.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 packet->AddHeader (dsrRoutingHeader);
 // Schedule the route requests retry with non-propagation set true
 bool nonProp = true;
 std::vector<Ipv4Address> address;
 NS_LOG_FUNCTION (this << (uint32_t)protocol);
 NS_ASSERT_MSG (!m_downTarget.IsNull (), "Error, DsrRouting cannot send downward");
 uint8_t salvage = rerr.GetSalvage ();
 Ipv4Address dst = rerr.GetOriginalDst ();
 NS_LOG_DEBUG ("our own address here " << m_mainAddress << " error source " << rerr.GetErrorSrc () << " error destination " << rerr.GetErrorDst ()
 << " error next hop " << rerr.GetUnreachNode () << " original dst " << rerr.GetOriginalDst ()
 );
 RouteCacheEntry toDst;
 if (m_routeCache->LookupRoute (dst, toDst))
 {
 /*
 * Found a route the dst, construct the source route option header
 rreqHeader.SetId (m_requestId);
 dsrRoutingHeader.AddDsrOption (rreqHeader);         // Add the rreqHeader to the dsr extension header
 dsrRoutingHeader.AddDsrOption (rerr);
 uint8_t length = rreqHeader.GetLength () + rerr.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 4);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 4);
 dstP->AddHeader (dsrRoutingHeader);
 // Schedule the route requests retry, propagate the route request message as it contains error
 bool nonProp = false;
 std::vector<Ipv4Address> address;
 address.push_back (m_mainAddress);
 }
 NS_LOG_DEBUG ("The request count for the destination " << dst << " " << m_rreqTable->GetRreqCnt (dst) << " with time value " << rreqDelay);
 if (rreqDelay > m_maxRequestPeriod)
 {
 // use the max request period
-NS_LOG_DEBUG ("The max request delay time " << m_maxRequestPeriod.GetSeconds());
+NS_LOG_DEBUG ("The max request delay time " << m_maxRequestPeriod.GetSeconds ());
 m_addressReqTimer[dst].Schedule (m_maxRequestPeriod);
 }
 else
 {
-NS_LOG_DEBUG ("The request delay time " << rreqDelay.GetSeconds());
+NS_LOG_DEBUG ("The request delay time " << rreqDelay.GetSeconds ());
 m_addressReqTimer[dst].Schedule (rreqDelay);
 }
 }
 }
 * The destination address here is directed broadcast address
 */
 uint32_t priority = GetPriority (DSR_CONTROL_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (packet, source, m_broadcast, Simulator::Now (), 0);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 dsrRoutingHeader.SetMessageType (1);
 dsrRoutingHeader.SetSourceId (GetIDfromIP (replySrc));
 dsrRoutingHeader.SetDestId (GetIDfromIP (replyDst));
 uint8_t length = rrep.GetLength ();        // Get the length of the rrep header excluding the type header
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 dsrRoutingHeader.AddDsrOption (rrep);
 Ptr<Packet> newPacket = Create<Packet> ();
 newPacket->AddHeader (dsrRoutingHeader);
 /*
 * Send gratuitous reply
 NS_LOG_INFO ("The output device " << dev << " packet is: " << *packet);
 uint32_t priority = GetPriority (DSR_CONTROL_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (packet, source, nextHop, Simulator::Now (), route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 ack.SetAckId (ackId);
 ack.SetRealSrc (realSrc);
 ack.SetRealDst (realDst);
 uint8_t length = ack.GetLength ();
-dsrRoutingHeader.SetPayloadLength (uint16_t(length) + 2);
+dsrRoutingHeader.SetPayloadLength (uint16_t (length) + 2);
 dsrRoutingHeader.AddDsrOption (ack);
 Ptr<Packet> packet = Create<Packet> ();
 packet->AddHeader (dsrRoutingHeader);
 Ptr<NetDevice> dev = m_ip->GetNetDevice (m_ip->GetInterfaceForAddress (m_mainAddress));
 NS_LOG_DEBUG ("Send out the ACK");
 uint32_t priority = GetPriority (DSR_CONTROL_PACKET);
 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator i = m_priorityQueue.find (priority);
 Ptr<dsr::DsrNetworkQueue> dsrNetworkQueue = i->second;
-NS_LOG_DEBUG("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
+NS_LOG_DEBUG ("Will be inserting into priority queue " << dsrNetworkQueue << " number: " << priority);
 DsrNetworkQueueEntry newEntry (packet, m_mainAddress, destination, Simulator::Now (), route);
 if (dsrNetworkQueue->Enqueue (newEntry))
 {
 uint8_t optionType = 0;
 uint8_t optionLength = 0;
 uint8_t segmentsLeft = 0;
 optionType = *(data);
-NS_LOG_LOGIC ("The option type value " << (uint32_t)optionType << " with packet size " << p->GetSize());
+NS_LOG_LOGIC ("The option type value " << (uint32_t)optionType << " with packet size " << p->GetSize ());
 dsrOption = GetOption (optionType);       // Get the relative dsr option and demux to the process function
 if (optionType == 1)        // This is the request option
 {
 BlackList *blackList = m_rreqTable->FindUnidirectional (src);
 if (nextProto != 0)
 {
 // we need to make a copy in the unlikely event we hit the
 // RX_ENDPOINT_UNREACH code path
 // Here we can use the packet that has been get off whole DSR header
-NS_LOG_DEBUG ("The packet size here " << copy->GetSize());
+NS_LOG_DEBUG ("The packet size here " << copy->GetSize ());
 NS_LOG_DEBUG ("The packet received " << *copy);
 enum IpL4Protocol::RxStatus status =
 nextProto->Receive (copy, ip, incomingInterface);
 NS_LOG_DEBUG ("The receive status " << status);
 switch (status)
 {
 case IpL4Protocol::RX_OK:
 // fall through
 case IpL4Protocol::RX_ENDPOINT_CLOSED:
 // fall through
 case IpL4Protocol::RX_CSUM_FAILED:
 break;
 case IpL4Protocol::RX_ENDPOINT_UNREACH:
 if (ip.GetDestination ().IsBroadcast () == true
 || ip.GetDestination ().IsMulticast () == true)
 {
 break;       // Do not reply to broadcast or multicast
 }

changeset 8756	9a34e618f40b
parent 8753	8d84b96e26bf
child 8784	d1201ff72e0c