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

equal deleted inserted replaced

-:efad81f3cb47
+:2da1fab73114
 return m_node;
 }
 bool DsrOptions::ContainAddressAfter (Ipv4Address ipv4Address, Ipv4Address destAddress, std::vector<Ipv4Address> &nodeList)
 {
+NS_LOG_FUNCTION (this << ipv4Address << destAddress);
 std::vector<Ipv4Address>::iterator it = find (nodeList.begin (), nodeList.end (), destAddress);
 for (std::vector<Ipv4Address>::iterator i = it; i != nodeList.end (); ++i)
 {
 if ((ipv4Address == (*i)) && ((*i) != nodeList.back ()))
 }
 std::vector<Ipv4Address>
 DsrOptions::CutRoute (Ipv4Address ipv4Address, std::vector<Ipv4Address> &nodeList)
 {
+NS_LOG_FUNCTION (this << ipv4Address);
 std::vector<Ipv4Address>::iterator it = find (nodeList.begin (), nodeList.end (), ipv4Address);
 std::vector<Ipv4Address> cutRoute;
 for (std::vector<Ipv4Address>::iterator i = it; i != nodeList.end (); ++i)
 {
 cutRoute.push_back (*i);
 return m_ipv4Route;
 }
 bool DsrOptions::ReverseRoutes (std::vector<Ipv4Address> & vec)
 {
+NS_LOG_FUNCTION (this);
 std::vector<Ipv4Address> vec2 (vec);
 vec.clear ();    // To ensure vec is empty before start
 for (std::vector<Ipv4Address>::reverse_iterator ri = vec2.rbegin (); ri
 != vec2.rend (); ++ri)
 {
 return false;
 }
 Ipv4Address DsrOptions::SearchNextHop (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec)
 {
+NS_LOG_FUNCTION (this << ipv4Address);
 Ipv4Address nextHop;
+NS_LOG_DEBUG ("the vector size " << vec.size ());
 if (vec.size () == 2)
 {
 NS_LOG_DEBUG ("The two nodes are neighbors");
 nextHop = vec[1];
 return nextHop;
 if (ipv4Address == vec.back ())
 {
 NS_LOG_DEBUG ("We have reached to the final destination " << ipv4Address << " " << vec.back ());
 return ipv4Address;
 }
-for (std::vector<Ipv4Address>::iterator i = vec.begin (); i != vec.end (); ++i)
+for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)
 {
 if (ipv4Address == (*i))
 {
 nextHop = *(++i);
 return nextHop;
 return none;
 }
 Ipv4Address DsrOptions::ReverseSearchNextHop (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec)
 {
+NS_LOG_FUNCTION (this << ipv4Address);
 Ipv4Address nextHop;
 if (vec.size () == 2)
 {
 NS_LOG_DEBUG ("The two nodes are neighbors");
 nextHop = vec[0];
 return none;
 }
 void DsrOptions::PrintVector (std::vector<Ipv4Address>& vec)
 {
+NS_LOG_FUNCTION (this);
 /*
 * Check elements in a route vector
 */
 if (!vec.size ())
 {
 }
 }
 bool DsrOptions::IfDuplicates (std::vector<Ipv4Address>& vec, std::vector<Ipv4Address>& vec2)
 {
+NS_LOG_FUNCTION (this);
+NS_LOG_DEBUG ("The first vector ");
+PrintVector (vec);
+NS_LOG_DEBUG ("The second vector ");
+PrintVector (vec2);
 for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)
 {
 for (std::vector<Ipv4Address>::const_iterator j = vec2.begin (); j != vec2.end (); ++j)
 {
 if ((*i) == (*j))
 return false;
 }
 bool DsrOptions::CheckDuplicates (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec)
 {
+NS_LOG_FUNCTION (this << ipv4Address);
 for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)
 {
 if ((*i) == ipv4Address)
 {
 return true;
 return false;
 }
 void DsrOptions::RemoveDuplicates (std::vector<Ipv4Address>& vec)
 {
+NS_LOG_FUNCTION (this);
 //Remove duplicate ip address from the route if any, should not happen with normal behavior nodes
 std::vector<Ipv4Address> vec2 (vec); // declare vec2 as a copy of the vec
 PrintVector (vec2); // Print all the ip address in the route
 vec.clear (); // clear vec
 for (std::vector<Ipv4Address>::const_iterator i = vec2.begin (); i != vec2.end (); ++i)
 }
 uint32_t
 DsrOptions::GetIDfromIP (Ipv4Address address)
 {
+NS_LOG_FUNCTION (this << address);
 int32_t nNodes = NodeList::GetNNodes ();
 for (int32_t i = 0; i < nNodes; ++i)
 {
 Ptr<Node> node = NodeList::GetNode (i);
 Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
 return 255;
 }
 Ptr<Node> DsrOptions::GetNodeWithAddress (Ipv4Address ipv4Address)
 {
+NS_LOG_FUNCTION (this << ipv4Address);
 int32_t nNodes = NodeList::GetNNodes ();
 for (int32_t i = 0; i < nNodes; ++i)
 {
 Ptr<Node> node = NodeList::GetNode (i);
 Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
 }
 uint8_t DsrOptionPad1::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc)
 {
 NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
 Ptr<Packet> p = packet->Copy ();
 DsrOptionPad1Header pad1Header;
 p->RemoveHeader (pad1Header);
 isPromisc = false;
 uint8_t DsrOptionPadn::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc)
 {
 NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
 Ptr<Packet> p = packet->Copy ();
 DsrOptionPadnHeader padnHeader;
 p->RemoveHeader (padnHeader);
 isPromisc = false;
 }
 uint8_t DsrOptionRreq::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc)
 {
 NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
+// Fields from IP header
+Ipv4Address srcAddress = ipv4Header.GetSource ();
+Ipv4Address destAddress = ipv4Header.GetDestination ();
+/*
+* \ when the ip source address is equal to the address of our own, this is request packet originated
+* \ by the node itself, discard it
+*/
+if (srcAddress == ipv4Address)
+{
+NS_LOG_DEBUG ("Discard the packet");
+m_dropTrace (packet); // call the drop trace to show in the tracing
+return 0;
+}
 /*
 * Get the node associated with the ipv4 address and get several objects from the node and leave for further use
 */
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
-Ptr<dsr::RouteCache> m_routeCache = node->GetObject<dsr::RouteCache> ();
-Ptr<dsr::RreqTable>  m_rreqTable = node->GetObject<dsr::RreqTable> ();
-ActiveRouteTimeout = m_routeCache->GetCacheTimeout ();
 // Set the isError boolean value as false
 bool isError = false;
 Ptr<Packet> p = packet->Copy (); // The packet here doesn't contain the fixed size dsr header
 /*
 * \peek the packet and get the value
 */
 uint8_t buf[2];
 p->CopyData (buf, sizeof(buf));
 uint8_t numberAddress = (buf[1] - 6) / 4;
+NS_LOG_DEBUG ("The number of Ip addresses " << (uint32_t)numberAddress);
 if (numberAddress >= 255)
 {
 NS_LOG_DEBUG ("Discard the packet, malformed header since two many ip addresses in route");
 m_dropTrace (packet); // call the drop trace to show in the tracing
 return 0;
 }
-NS_LOG_DEBUG ("The number of Ip addresses " << (uint32_t)numberAddress);
 /*
 * Create the dsr rreq header
 */
 DsrOptionRreqHeader rreq;
-// Fields from IP header
-Ipv4Address srcAddress = ipv4Header.GetSource ();
-Ipv4Address destAddress = ipv4Header.GetDestination ();
 /*
 * Set the number of addresses with the value from peek data and remove the rreq header
 */
 rreq.SetNumberAddress (numberAddress);
+// Remove the route request header
-/*
+p->RemoveHeader (rreq);
-* \ when the ip source address is equal to the address of our own, this is request packet originated
+// Verify the option length
-* \ by the node itself, discard it
+uint8_t length = rreq.GetLength ();
-*/
+if (length % 2 != 0)
-if (srcAddress == ipv4Address)
+{
-{
+NS_LOG_LOGIC ("Malformed header. Drop!");
-NS_LOG_DEBUG ("Discard the packet");
+m_dropTrace (packet); // call drop trace
-m_dropTrace (packet); // call the drop trace to show in the tracing
 return 0;
 }
-p->RemoveHeader (rreq);
-Ptr<Packet> errP = p->Copy ();
 // The target address is where we want to send the data packets
 Ipv4Address targetAddress = rreq.GetTarget ();
-uint16_t id = rreq.GetId ();
 // Get the node list and source address from the route request header
-std::vector<Ipv4Address> nodeList = rreq.GetNodesAddresses ();
+std::vector<Ipv4Address> mainVector = rreq.GetNodesAddresses ();
+std::vector<Ipv4Address> nodeList (mainVector);
 PrintVector (nodeList);
+/*
-// Get the TTL value
+* Construct the dsr routing header for future use
-uint8_t ttl = ipv4Header.GetTtl ();
+*/
-NS_LOG_DEBUG ("The TTL " << (uint32_t) ttl);
+DsrRoutingHeader dsrRoutingHeader;
-/*
+dsrRoutingHeader.SetNextHeader (protocol);
-*  Node checks to determine whether it has received a RREQ with the same Originator IP Address and RREQ ID.
+dsrRoutingHeader.SetMessageType (1);
-*  If such a RREQ has been received, the node silently discards the newly received RREQ.
+dsrRoutingHeader.SetSourceId (GetIDfromIP (source));
-*/
+dsrRoutingHeader.SetDestId (255);
-if (ttl)
-{
-// if the TTL value is not 0, save the route request entry
-if (m_rreqTable->FindSrc (source, targetAddress, id))
-{
-NS_LOG_DEBUG ("Received the same route request recently, not processing it further");
-return 0;
-}
-}
 if (CheckDuplicates (ipv4Address, nodeList))
 {
 /*
 * if the route contains the node address already, drop the request packet
 NS_LOG_DEBUG ("Our node address is already seen in the route, drop the request");
 return 0;
 }
 else
 {
-// Verify the option length
-uint8_t length = rreq.GetLength ();
-if (length % 2 != 0)
-{
-NS_LOG_LOGIC ("Malformed header. Drop!");
-m_dropTrace (packet); // call drop trace
-return 0;
-}
 // A node ignores all RREQs received from any node in its blacklist
 RouteCacheEntry toPrev;
 /*
 *  When the reverse route is created or updated, the following actions on the route are also carried out:
 *  3. the next hop in the routing table becomes the node from which the  RREQ was received
 //  A node generates a RREP if either:
 //  (i)  it is itself the destination,
 /*
 * The target address equal to our own ip address
 */
+NS_LOG_DEBUG ("The target address over here " << targetAddress << " and the ip address " << ipv4Address << " and the source address " << mainVector[0]);
 if (targetAddress == ipv4Address)
 {
 Ipv4Address nextHop; // Declare the next hop address to use
 if (nodeList.size () == 1)
 {
 m_finalRoute.push_back (ipv4Address);    // push back our own address
 nextHop = srcAddress;
 }
 else
 {
-nodeList.push_back (ipv4Address);    // push back our own address
+std::vector<Ipv4Address> changeRoute (nodeList);
+changeRoute.push_back (ipv4Address);    // push back our own address
 m_finalRoute.clear ();              // get a clear route vector
-for (std::vector<Ipv4Address>::iterator i = nodeList.begin (); i != nodeList.end (); ++i)
+for (std::vector<Ipv4Address>::iterator i = changeRoute.begin (); i != changeRoute.end (); ++i)
 {
 m_finalRoute.push_back (*i);  // Get the full route from source to destination
 }
 PrintVector (m_finalRoute);
 nextHop = ReverseSearchNextHop (ipv4Address, m_finalRoute); // get the next hop
 DsrOptionRrepHeader rrep;
 rrep.SetNodesAddress (m_finalRoute);     // Set the node addresses in the route reply header
 NS_LOG_DEBUG ("The nextHop address " << nextHop);
 Ipv4Address replyDst = m_finalRoute.front ();
 /*
-* This part add dsr header to the packet and send reply
+* This part add dsr header to the packet and send route reply packet
 */
 DsrRoutingHeader dsrRoutingHeader;
 dsrRoutingHeader.SetNextHeader (protocol);
 dsrRoutingHeader.SetMessageType (1);
 dsrRoutingHeader.SetSourceId (GetIDfromIP (ipv4Address));
 PrintVector (m_finalRoute);
 Ipv4Address dst = m_finalRoute.back ();
 bool addRoute = false;
 if (numberAddress > 0)
 {
-RouteCacheEntry toSource (/*IP_VECTOR=*/ m_finalRoute, /*dst=*/
+RouteCacheEntry toSource (/*IP_VECTOR=*/m_finalRoute, /*dst=*/
-dst, /*expire time=*/ ActiveRouteTimeout);
+dst, /*expire time=*/ActiveRouteTimeout);
-if (m_routeCache->IsLinkCache ())
+if (dsr->IsLinkCache ())
 {
-addRoute = m_routeCache->AddRoute_Link (m_finalRoute, ipv4Address);
+addRoute = dsr->AddRoute_Link (m_finalRoute, ipv4Address);
 }
 else
 {
-addRoute = m_routeCache->AddRoute (toSource);
+addRoute = dsr->AddRoute (toSource);
 }
 }
 else
 {
 NS_LOG_DEBUG ("Abnormal RouteRequest");
 return 0;
 }
 if (addRoute)
 {
-NS_LOG_DEBUG ("The route is failed to add in cache");
-return 0;
-}
-else
-{
 /*
 * Found a route to the dst, construct the source route option header
 */
 DsrOptionSRHeader sourceRoute;
 NS_LOG_DEBUG ("The route length " << m_finalRoute.size ());
 sourceRoute.SetNodesAddress (m_finalRoute);
-if (m_routeCache->IsLinkCache ())
+if (dsr->IsLinkCache ())
 {
-m_routeCache->UseExtends (m_finalRoute);
+dsr->UseExtends (m_finalRoute);
 }
 sourceRoute.SetSegmentsLeft ((m_finalRoute.size () - 2));
-uint8_t salvage = 0;
+// The salvage value here is 0
-sourceRoute.SetSalvage (salvage);
+sourceRoute.SetSalvage (0);
 Ipv4Address nextHop = SearchNextHop (ipv4Address, m_finalRoute); // Get the next hop address
 NS_LOG_DEBUG ("The nextHop address " << nextHop);
 if (nextHop == "0.0.0.0")
 {
 dsr->PacketNewRoute (dsrP, ipv4Address, dst, protocol);
 return 0;
 }
 SetRoute (nextHop, ipv4Address);
 /*
-* Schedule the packet retry
+* Send the data packet from the send buffer
 */
-dsr->SendPacket (sourceRoute, nextHop, protocol);
+dsr->SendPacketFromBuffer (sourceRoute, nextHop, protocol);
-// Cancel the route request timer for destination
+// Cancel the route request timer for destination after sending the data packet
-dsr->CancelRreqTimer (dst);
+dsr->CancelRreqTimer (dst, true);
+}
+else
+{
+NS_LOG_DEBUG ("The route is failed to add in cache");
+return 0;
 }
 }
 else
 {
 NS_LOG_DEBUG ("Unable to reverse route");
 /*
 * (ii) or it has an active route to the destination, send reply based on request header and route cache,
 *      need to delay based on a random value from d = H * (h - 1 + r), which can avoid possible route
 *      reply storm.
 */
-else if (m_routeCache->LookupRoute (targetAddress, toPrev))
+else if (dsr->LookupRoute (targetAddress, toPrev))
 {
 RouteCacheEntry::IP_VECTOR ip = toPrev.GetVector (); // The route from our own route cache to dst
 PrintVector (ip);
-std::vector<Ipv4Address> nodeList = rreq.GetNodesAddresses (); // Route from rreq header
 std::vector<Ipv4Address> saveRoute (nodeList);
 PrintVector (saveRoute);
 // Verify if the two vector contains duplicates, if so, do not use
 // the route found and forward the route request
-if (!(IfDuplicates (ip, nodeList)))
+if (!(IfDuplicates (ip, saveRoute)))
 {
-m_finalRoute.clear (); // Clear the final route vector
+m_finalRoute.clear ();            // Clear the final route vector
 /**
 * push back the intermediate node address from the source to this node
 */
-for (std::vector<Ipv4Address>::iterator i = nodeList.begin (); i != nodeList.end (); ++i)
+for (std::vector<Ipv4Address>::iterator i = saveRoute.begin (); i != saveRoute.end (); ++i)
 {
 m_finalRoute.push_back (*i);
 }
 /**
 * push back the route vector we found in our route cache to destination, including this node's address
 bool addRoute = false;
 std::vector<Ipv4Address> reverseRoute (m_finalRoute);
 if (ReverseRoutes (reverseRoute))
 {
-Ipv4Address dst = reverseRoute.back ();
 saveRoute.push_back (ipv4Address);
 ReverseRoutes (saveRoute);
+Ipv4Address dst = saveRoute.back ();
+NS_LOG_DEBUG ("This is the route save in route cache");
 PrintVector (saveRoute);
 RouteCacheEntry toSource (/*IP_VECTOR=*/ saveRoute, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout);
 NS_ASSERT (saveRoute.front () == ipv4Address);
 // Add the route entry in the route cache
-if (m_routeCache->IsLinkCache ())
+if (dsr->IsLinkCache ())
 {
-addRoute = m_routeCache->AddRoute_Link (saveRoute, ipv4Address);
+addRoute = dsr->AddRoute_Link (saveRoute, ipv4Address);
 }
 else
 {
-addRoute = m_routeCache->AddRoute (toSource);
+addRoute = dsr->AddRoute (toSource);
 }
 if (addRoute)
-{
-NS_LOG_DEBUG ("The route is failed to add in cache");
-return 0;
-}
-else
 {
 NS_LOG_DEBUG ("We have added the route and search send buffer for packet with destination " << dst);
 /*
 * Found a route the dst, construct the source route option header
 */
 DsrOptionSRHeader sourceRoute;
-NS_LOG_DEBUG ("The route length " << reverseRoute.size ());
+PrintVector (saveRoute);
-sourceRoute.SetNodesAddress (reverseRoute);
-if (m_routeCache->IsLinkCache ())
+sourceRoute.SetNodesAddress (saveRoute);
+if (dsr->IsLinkCache ())
 {
-m_routeCache->UseExtends (reverseRoute);
+dsr->UseExtends (saveRoute);
 }
 sourceRoute.SetSegmentsLeft ((saveRoute.size () - 2));
 uint8_t salvage = 0;
 sourceRoute.SetSalvage (salvage);
-Ipv4Address nextHop = SearchNextHop (ipv4Address, reverseRoute); // Get the next hop address
+Ipv4Address nextHop = SearchNextHop (ipv4Address, saveRoute); // Get the next hop address
 NS_LOG_DEBUG ("The nextHop address " << nextHop);
 if (nextHop == "0.0.0.0")
 {
 dsr->PacketNewRoute (dsrP, ipv4Address, dst, protocol);
 }
 SetRoute (nextHop, ipv4Address);
 /*
 * Schedule the packet retry
 */
-dsr->SendPacket (sourceRoute, nextHop, protocol);
+dsr->SendPacketFromBuffer (sourceRoute, nextHop, protocol);
 // Cancel the route request timer for destination
-dsr->CancelRreqTimer (dst);
+dsr->CancelRreqTimer (dst, true);
+}
+else
+{
+NS_LOG_DEBUG ("The route is failed to add in cache");
+return 0;
 }
 }
 else
 {
 NS_LOG_DEBUG ("Unable to reverse the route");
+return 0;
 }
 /*
 * Need to first pin down the next hop address before removing duplicates
 */
 Ipv4Address nextHop = ReverseSearchNextHop (ipv4Address, m_finalRoute);
+NS_LOG_DEBUG ("The nextHop address " << nextHop);
 /*
 * First remove the duplicate ip address to automatically shorten the route, and then reversely
 * search the next hop address
 */
-PrintVector (m_finalRoute);
 // Set the route
 SetRoute (nextHop, ipv4Address);
 uint16_t hops = m_finalRoute.size ();
 DsrOptionRrepHeader rrep;
 rrep.SetNodesAddress (m_finalRoute);     // Set the node addresses in the route reply header
-NS_LOG_DEBUG ("The nextHop address " << nextHop);
 // Get the real source of the reply
 Ipv4Address realSource = m_finalRoute.back ();
+Ipv4Address realDst = m_finalRoute.front ();
+PrintVector (m_finalRoute);
+NS_LOG_DEBUG ("This is the full route from " << realSource << " to " << realDst);
 /*
-* This part add dsr header to the packet and send reply
+* This part add dsr header to the packet and send route reply packet
 */
 DsrRoutingHeader dsrRoutingHeader;
 dsrRoutingHeader.SetNextHeader (protocol);
 dsrRoutingHeader.SetMessageType (1);
 dsrRoutingHeader.SetSourceId (GetIDfromIP (realSource));
 Ptr<Packet> newPacket = Create<Packet> ();
 newPacket->AddHeader (dsrRoutingHeader);
 dsr->ScheduleCachedReply (newPacket, ipv4Address, nextHop, m_ipv4Route, hops);
 isPromisc = false;
 }
+else
+{
+NS_LOG_DEBUG ("There is duplicate ip addresses in the two route parts");
+}
+return rreq.GetSerializedSize ();
 }
 /*
 * (iii) no route in any type has been found
 */
 else
 {
-std::vector<Ipv4Address> nodeList = rreq.GetNodesAddresses (); // route from rreq header
+mainVector.push_back (ipv4Address);
-PrintVector (nodeList);
+NS_ASSERT (mainVector.front () == source);
-/*
+NS_LOG_DEBUG ("Print out the main vector");
-* Otherwise, forward the route request packet
+PrintVector (mainVector);
-*/
+rreq.SetNodesAddress (mainVector);
-PrintVector (nodeList);
-nodeList.push_back (ipv4Address);
+Ptr<Packet> errP = p->Copy ();
-PrintVector (nodeList);
+if (errP->GetSize ())
-NS_ASSERT (nodeList.front () == source);
+{
-rreq.SetNodesAddress (nodeList);
+NS_LOG_DEBUG ("Error header included");
+DsrOptionRerrUnreachHeader rerr;
+p->RemoveHeader (rerr);
+Ipv4Address errorSrc = rerr.GetErrorSrc ();
+Ipv4Address unreachNode = rerr.GetUnreachNode ();
+Ipv4Address errorDst = rerr.GetErrorDst ();
+if ((errorSrc == srcAddress) && (unreachNode == ipv4Address))
+{
+NS_LOG_DEBUG ("The error link back to work again");
+uint16_t length = rreq.GetLength ();
+NS_LOG_DEBUG ("The RREQ header length " <<  length);
+dsrRoutingHeader.AddDsrOption (rreq);
+dsrRoutingHeader.SetPayloadLength (length + 2);
+}
+else
+{
+isError = true;
+dsr->DeleteAllRoutesIncludeLink (errorSrc, unreachNode, ipv4Address);
+DsrOptionRerrUnreachHeader newUnreach;
+newUnreach.SetErrorType (1);
+newUnreach.SetErrorSrc (errorSrc);
+newUnreach.SetUnreachNode (unreachNode);
+newUnreach.SetErrorDst (errorDst);
+newUnreach.SetSalvage (rerr.GetSalvage ()); // Set the value about whether to salvage a packet or not
+uint16_t length = rreq.GetLength () + newUnreach.GetLength ();
+NS_LOG_DEBUG ("The RREQ and newUnreach header length " <<  length);
+dsrRoutingHeader.SetPayloadLength (length + 4);
+dsrRoutingHeader.AddDsrOption (rreq);
+dsrRoutingHeader.AddDsrOption (newUnreach);
+}
+}
+else
+{
+uint16_t length = rreq.GetLength ();
+NS_LOG_DEBUG ("The RREQ header length " <<  length);
+dsrRoutingHeader.AddDsrOption (rreq);
+dsrRoutingHeader.SetPayloadLength (length + 2);
+}
+// Get the TTL value
+uint8_t ttl = ipv4Header.GetTtl ();
 /*
 * Decrease the TTL value in the packet tag by one, this tag will go to ip layer 3 send function
 * and drop packet when TTL value equals to 0
 */
+NS_LOG_DEBUG ("The ttl value here " << (uint32_t)ttl);
 if (ttl)
 {
 Ptr<Packet> interP = Create<Packet> ();
 SocketIpTtlTag tag;
 tag.SetTtl (ttl - 1);
 interP->AddPacketTag (tag);
-/*
+interP->AddHeader (dsrRoutingHeader);
-* Construct the route request header to forward the route requests
-*/
-DsrRoutingHeader dsrRoutingHeader;
-dsrRoutingHeader.SetNextHeader (protocol);
-dsrRoutingHeader.SetMessageType (1);
-dsrRoutingHeader.SetSourceId (GetIDfromIP (source));
-dsrRoutingHeader.SetDestId (255);
-dsrRoutingHeader.AddDsrOption (rreq);
-// if the errP packet is not 0, then there is an error header after it
-if (errP->GetSize ())
-{
-NS_LOG_DEBUG ("Error header included");
-DsrOptionRerrUnreachHeader rerr;
-p->RemoveHeader (rerr);
-Ipv4Address errorSrc = rerr.GetErrorSrc ();
-Ipv4Address unreachNode = rerr.GetUnreachNode ();
-isError = true;
-m_routeCache->DeleteAllRoutesIncludeLink (errorSrc, unreachNode, ipv4Address);
-DsrOptionRerrUnreachHeader newUnreach;
-newUnreach.SetErrorType (1);
-newUnreach.SetErrorSrc (rerr.GetErrorSrc ());
-newUnreach.SetUnreachNode (rerr.GetUnreachNode ());
-newUnreach.SetErrorDst (rerr.GetErrorDst ());
-newUnreach.SetSalvage (rerr.GetSalvage ()); // Set the value about whether to salvage a packet or not
-dsrRoutingHeader.AddDsrOption (newUnreach);
-uint16_t length = rreq.GetLength () + newUnreach.GetLength ();
-NS_LOG_DEBUG ("The RREQ and newUnreach header length " <<  length);
-dsrRoutingHeader.SetPayloadLength (length + 4);
-interP->AddHeader (dsrRoutingHeader);
-}
-else
-{
-uint16_t length = rreq.GetLength ();
-NS_LOG_DEBUG ("The RREQ header length " <<  length);
-dsrRoutingHeader.SetPayloadLength (length + 2);
-interP->AddHeader (dsrRoutingHeader);
-}
 dsr->ScheduleInterRequest (interP);
 isPromisc = false;
 }
-}
+return rreq.GetSerializedSize ();
 }
+}
 return rreq.GetSerializedSize ();
 }
 NS_OBJECT_ENSURE_REGISTERED (DsrOptionRrep);
 rrep.SetNumberAddress (numberAddress);  // Set the number of ip address in the header to reserver space for deserialize header
 p->RemoveHeader (rrep);
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
-Ptr<dsr::RouteCache> m_routeCache = node->GetObject<dsr::RouteCache> ();
-Ptr<dsr::RreqTable>  m_rreqTable = node->GetObject<dsr::RreqTable> ();
-ActiveRouteTimeout = m_routeCache->GetCacheTimeout ();
 NS_LOG_DEBUG ("The next header value " << (uint32_t)protocol);
 std::vector<Ipv4Address> nodeList = rrep.GetNodesAddress ();
-/*
+/**
 * Get the destination address, which is the last element in the nodeList
 */
 Ipv4Address targetAddress = nodeList.front ();
 // If the RREP option has reached to the destination
 if (targetAddress == ipv4Address)
 if (nodeList.size () == 0)
 {
 NS_LOG_DEBUG ("The route we have contains 0 entries");
 return 0;
 }
-/*
+/**
 * Get the destination address for the data packet, which is the last element in the nodeList
 */
 Ipv4Address dst = nodeList.back ();
-/*
+/**
 * Add the newly found route to the route cache
 * The route looks like:
 * \\ "srcAddress" + "intermediate node address" + "targetAddress"
 */
 RouteCacheEntry toDestination (/*IP_VECTOR=*/ nodeList, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout);
 NS_ASSERT (nodeList.front () == ipv4Address);
 bool addRoute = false;
-if (m_routeCache->IsLinkCache ())
+if(dsr->IsLinkCache())
 {
-m_routeCache->AddRoute_Link (nodeList, ipv4Address);
+addRoute = dsr->AddRoute_Link (nodeList, ipv4Address);
 }
 else
 {
-m_routeCache->AddRoute (toDestination);
+addRoute = dsr->AddRoute (toDestination);
 }
 if (addRoute)
 {
-NS_LOG_DEBUG ("Failed to add the route");
-return 0;
-}
-else
-{
 NS_LOG_DEBUG ("We have added the route and search send buffer for packet with destination " << dst);
-/*
+/**
 * Found a route the dst, construct the source route option header
 */
 DsrOptionSRHeader sourceRoute;
 NS_LOG_DEBUG ("The route length " << nodeList.size ());
 sourceRoute.SetNodesAddress (nodeList);
 sourceRoute.SetSegmentsLeft ((nodeList.size () - 2));
-uint8_t salvage = 0;
+sourceRoute.SetSalvage (0);
-sourceRoute.SetSalvage (salvage);
 Ipv4Address nextHop = SearchNextHop (ipv4Address, nodeList); // Get the next hop address
 NS_LOG_DEBUG ("The nextHop address " << nextHop);
 if (nextHop == "0.0.0.0")
 {
 dsr->PacketNewRoute (dsrP, ipv4Address, dst, protocol);
 return 0;
 }
 PrintVector (nodeList);
 SetRoute (nextHop, ipv4Address);
-/*
+// Cancel the route request timer for destination
+dsr->CancelRreqTimer (dst, true);
+/**
 * Schedule the packet retry
 */
-dsr->SendPacket (sourceRoute, nextHop, protocol);
+dsr->SendPacketFromBuffer (sourceRoute, nextHop, protocol);
-// Cancel the route request timer for destination
+}
-dsr->CancelRreqTimer (dst);
+else
+{
+NS_LOG_DEBUG ("Failed to add the route");
+return 0;
 }
 }
 else
 {
 uint8_t length = rrep.GetLength () - 2; // The get length - 2 is to get aligned for the malformed header check
 Ipv4Address dst = cutRoute.back ();
 NS_LOG_DEBUG ("The route destination after cut " << dst);
 RouteCacheEntry toDestination (/*IP_VECTOR=*/ cutRoute, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout);
 NS_ASSERT (cutRoute.front () == ipv4Address);
 bool addRoute = false;
-if (m_routeCache->IsLinkCache ())
+if(dsr->IsLinkCache())
 {
-m_routeCache->AddRoute_Link (nodeList, ipv4Address);
+addRoute = dsr->AddRoute_Link (nodeList, ipv4Address);
 }
 else
 {
-m_routeCache->AddRoute (toDestination);
+addRoute = dsr->AddRoute (toDestination);
 }
 if (addRoute)
 {
-dsr->CancelRreqTimer (dst);
+dsr->CancelRreqTimer (dst, true);
 }
 else
 {
 NS_LOG_DEBUG ("The route not added");
 }
 sourceRoute.SetNumberAddress (numberAddress);
 p->RemoveHeader (sourceRoute);
 // The route size saved in the source route
 std::vector<Ipv4Address> nodeList = sourceRoute.GetNodesAddress ();
 uint8_t segsLeft = sourceRoute.GetSegmentsLeft ();
 uint8_t salvage = sourceRoute.GetSalvage ();
-// Here we remove the ack packet to the previous hop
-DsrOptionAckReqHeader ackReq;
-p->RemoveHeader (ackReq);
-uint16_t ackId = ackReq.GetAckId ();
 /*
 * Get the node from IP address and get the DSR extension object
 */
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
 /*
 * Get the node from Ip address and get the dsr routing object
 */
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
+bool findSame = dsr->FindSamePackets (packet, source, destination, segsLeft);
-bool findSame = dsr->FindSamePackets (packet, ipv4Header, source, destination, segsLeft);
 if (findSame)
 {
-NS_LOG_DEBUG ("Received one passive acknowledgment for data packet");
+NS_LOG_DEBUG ("Received one passive acknowledgment for a successfully delivered packet");
 }
 if (ContainAddressAfter (ipv4Address, destAddress, nodeList))
 {
 NS_LOG_DEBUG ("Send back the gratuitous reply");
 dsr->SendGratuitousReply (source, srcAddress, nodeList, protocol);
 * Get the number of address from the source route header
 */
 uint8_t length = sourceRoute.GetLength ();
 uint8_t nextAddressIndex;
 Ipv4Address nextAddress;
-/*
-* Send back acknowledgment packet to the earlier hop
+// Get the option type value
-*/
+uint32_t size = p->GetSize ();
-m_ipv4Route = SetRoute (srcAddress, ipv4Address);
+uint8_t *data = new uint8_t[size];
-NS_LOG_DEBUG ("Send back ACK to the earlier hop " << srcAddress << " from us " << ipv4Address);
+p->CopyData (data, size);
-dsr->SendAck (ackId, srcAddress, source, destination, protocol, m_ipv4Route);
+uint8_t optionType = 0;
+optionType = *(data);
+NS_LOG_DEBUG ("The packet size over here " << p->GetSize());
+NS_LOG_DEBUG ("The option type over here " << (uint32_t)optionType);
+if (optionType == 160)
+{
+NS_LOG_DEBUG ("Here we remove the ack request header and add ack header to the packet");
+// Here we remove the ack packet to the previous hop
+DsrOptionAckReqHeader ackReq;
+p->RemoveHeader (ackReq);
+uint16_t ackId = ackReq.GetAckId ();
+NS_LOG_DEBUG ("The type value " << (uint32_t)ackReq.GetType ());
+/*
+* Send back acknowledgment packet to the earlier hop
+*/
+m_ipv4Route = SetRoute (srcAddress, ipv4Address);
+NS_LOG_DEBUG ("Send back ACK to the earlier hop " << srcAddress << " from us " << ipv4Address);
+dsr->SendAck (ackId, srcAddress, source, destination, protocol, m_ipv4Route);
+}
 /*
 * After send back ACK, check if the segments left value has turned to 0 or not, if yes, update the route entry
 * and return header length
 */
 if (segsLeft == 0)
 {
+NS_LOG_DEBUG ("This is the final destination");
 isPromisc = false;
 return sourceRoute.GetSerializedSize ();
 }
 if (length % 2 != 0)
 m_dropTrace (packet);
 return 0;
 }
 // Set the route and forward the data packet
 SetRoute (nextAddress, ipv4Address);
+NS_LOG_DEBUG ("dsr packet size " << dsrP->GetSize());
 dsr->ForwardPacket (dsrP, newSourceRoute, ipv4Header, realSource, nextAddress, targetAddress, protocol, m_ipv4Route);
 }
 return sourceRoute.GetSerializedSize ();
 }
 }
 uint8_t DsrOptionRerr::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc)
 {
 NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
 Ptr<Packet> p = packet->Copy ();
 uint32_t size = p->GetSize ();
 uint8_t *data = new uint8_t[size];
 p->CopyData (data, size);
 uint8_t errorType = *(data + 2);
 /*
 * Get the node from Ip address and get the dsr extension object
 */
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
-Ipv4Address srcAddress = ipv4Header.GetSource ();
-Ipv4Address destAddress = ipv4Header.GetDestination ();
 /*
 * The error serialized size
 */
 uint32_t rerrSize;
+NS_LOG_DEBUG ("The error type value here " << (uint32_t)errorType);
 if (errorType == 1) // unreachable ip address
 {
 /*
 * Remove the route error header from the packet, and get the error type
 */
 rerrSize = rerrUnreach.GetSerializedSize ();
 /*
 * Delete all the routes including the unreachable node address from the route cache
 */
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
-Ptr<dsr::RouteCache> m_routeCache = node->GetObject<dsr::RouteCache> ();
+dsr->DeleteAllRoutesIncludeLink (errorSource, unreachAddress, ipv4Address);
-m_routeCache->DeleteAllRoutesIncludeLink (errorSource, unreachAddress, ipv4Address);
 Ptr<Packet> newP = p->Copy ();
 uint32_t serialized = DoSendError (newP, rerrUnreach, rerrSize, ipv4Address, protocol);
 return serialized;
 }
 */
 DsrOptionRerrUnsupportHeader rerrUnsupport;
 p->RemoveHeader (rerrUnsupport);
 rerrSize = rerrUnsupport.GetSerializedSize ();
-// This is for the other two error options TODO
+// This is for the other two error options, not supporting for now TODO
 //      uint32_t serialized = DoSendError (p, rerrUnsupport, rerrSize, ipv4Address, protocol);
 uint32_t serialized = 0;
 return serialized;
 }
 }
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
 /*
 * Get the segments left field and the next address
 */
 uint8_t segmentsLeft = sourceRoute.GetSegmentsLeft ();
-NS_LOG_DEBUG ("The segments left " << (uint32_t)segmentsLeft);
 uint8_t length = sourceRoute.GetLength ();
-NS_LOG_DEBUG ("The number of addresses we have " << (uint32_t)numberAddress);
 uint8_t nextAddressIndex;
 Ipv4Address nextAddress;
 /*
 * Get the route size and the error target address
 */
 /*
 * When the error packet has reached to the destination
 */
 if (segmentsLeft == 0 && targetAddress == ipv4Address)
 {
-NS_LOG_DEBUG ("This is the destination of the error");
+NS_LOG_INFO ("This is the destination of the error, send error request");
 dsr->SendErrorRequest (rerr, protocol);
 return serializedSize;
 }
-DsrOptionRerrUnreachHeader newUnreach;
-newUnreach.SetErrorType (1);
-newUnreach.SetErrorSrc (rerr.GetErrorSrc ());
-newUnreach.SetUnreachNode (rerr.GetUnreachNode ());
-newUnreach.SetErrorDst (rerr.GetErrorDst ());
-newUnreach.SetSalvage (rerr.GetSalvage ()); // Set the value about whether to salvage a packet or not
 // Get the next Router Address
 DsrOptionSRHeader newSourceRoute;
 newSourceRoute.SetSegmentsLeft (segmentsLeft - 1);
 nextAddressIndex = numberAddress - segmentsLeft;
 return serializedSize;
 }
 // Set the route entry
 SetRoute (nextAddress, ipv4Address);
-dsr->ForwardErrPacket (newUnreach, newSourceRoute, nextAddress, protocol, m_ipv4Route);
+dsr->ForwardErrPacket (rerr, newSourceRoute, nextAddress, protocol, m_ipv4Route);
 return serializedSize;
 }
 NS_OBJECT_ENSURE_REGISTERED (DsrOptionAckReq);
 /*
 * Get the node with ip address and get the dsr extension and reoute cache objects
 */
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
-Ptr<dsr::RouteCache> m_routeCache = node->GetObject<dsr::RouteCache> ();
 NS_LOG_DEBUG ("The next header value " << (uint32_t)protocol);
 Ipv4Address srcAddress = ipv4Header.GetSource ();
 SetRoute (srcAddress, ipv4Address);
 /*
 * Get the node with ip address and get the dsr extension and route cache objects
 */
 Ptr<Node> node = GetNodeWithAddress (ipv4Address);
 Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
-Ptr<dsr::RouteCache> srcRouteCache = node->GetObject<dsr::RouteCache> ();
+dsr->UpdateRouteEntry (realDst);
-srcRouteCache->UpdateRouteEntry (realDst);
 /*
 * Cancel the packet retransmit timer when receiving the ack packet
 */
 dsr->CallCancelPacketTimer (ackId, ipv4Header, realSrc, realDst);
 return ack.GetSerializedSize ();

changeset 8752	2da1fab73114
parent 8751	efad81f3cb47
child 8753	8d84b96e26bf