diff --git a/src/internet-stack/raw-socket-impl.cc b/src/internet-stack/raw-socket-impl.cc new file mode 100644 index 000000000..7f495db94 --- /dev/null +++ b/src/internet-stack/raw-socket-impl.cc @@ -0,0 +1,299 @@ +#include "raw-socket-impl.h" +#include "ipv4-l3-protocol.h" +#include "icmpv4.h" +#include "ns3/inet-socket-address.h" +#include "ns3/node.h" +#include "ns3/packet.h" +#include "ns3/uinteger.h" +#include "ns3/log.h" +#include "ipv4-interface.h" + + +NS_LOG_COMPONENT_DEFINE ("RawSocketImpl"); + +namespace ns3 +{ + +NS_OBJECT_ENSURE_REGISTERED (RawSocketImpl); + +TypeId +RawSocketImpl::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::RawSocketImpl") .SetParent () .AddAttribute ("Protocol", "Protocol number to match.", UintegerValue (0), + MakeUintegerAccessor (&RawSocketImpl::m_protocol), MakeUintegerChecker ()) .AddAttribute ("IcmpFilter", + "Any icmp header whose type field matches a bit in this filter is dropped.", UintegerValue (0), MakeUintegerAccessor ( + &RawSocketImpl::m_icmpFilter), MakeUintegerChecker ()); + return tid; +} + +RawSocketImpl::RawSocketImpl () +{ + NS_LOG_FUNCTION (this); + m_err = Socket::ERROR_NOTERROR; + m_node = 0; + m_src = Ipv4Address::GetAny (); + m_dst = Ipv4Address::GetAny (); + m_protocol = 0; + m_shutdownSend = false; + m_shutdownRecv = false; +} + +void +RawSocketImpl::SetNode (Ptr node) +{ + m_node = node; +} + +void +RawSocketImpl::DoDispose (void) +{ + NS_LOG_FUNCTION (this); + m_node = 0; + Socket::DoDispose (); +} + +enum Socket::SocketErrno +RawSocketImpl::GetErrno (void) const +{ + NS_LOG_FUNCTION (this); + return m_err; +} +Ptr +RawSocketImpl::GetNode (void) const +{ + NS_LOG_FUNCTION (this); + return m_node; +} +int +RawSocketImpl::Bind (const Address &address) +{ + NS_LOG_FUNCTION (this << address); + if (!InetSocketAddress::IsMatchingType (address)) + { + m_err = Socket::ERROR_INVAL; + return -1; + } + InetSocketAddress ad = InetSocketAddress::ConvertFrom (address); + m_src = ad.GetIpv4 (); + return 0; +} +int +RawSocketImpl::Bind (void) +{ + NS_LOG_FUNCTION (this); + m_src = Ipv4Address::GetAny (); + return 0; +} +int +RawSocketImpl::GetSockName (Address &address) const +{ + address = InetSocketAddress (m_src, 0); + return 0; +} +int +RawSocketImpl::Close (void) +{ + NS_LOG_FUNCTION (this); + Ptr ipv4 = m_node->GetObject (); + if (ipv4 != 0) + { + ipv4->DeleteRawSocket (this); + } + return 0; +} +int +RawSocketImpl::ShutdownSend (void) +{ + NS_LOG_FUNCTION (this); + m_shutdownSend = true; + return 0; +} +int +RawSocketImpl::ShutdownRecv (void) +{ + NS_LOG_FUNCTION (this); + m_shutdownRecv = true; + return 0; +} +int +RawSocketImpl::Connect (const Address &address) +{ + NS_LOG_FUNCTION (this << address); + if (!InetSocketAddress::IsMatchingType (address)) + { + m_err = Socket::ERROR_INVAL; + return -1; + } + InetSocketAddress ad = InetSocketAddress::ConvertFrom (address); + m_dst = ad.GetIpv4 (); + return 0; +} +int +RawSocketImpl::Listen (void) +{ + NS_LOG_FUNCTION (this); + m_err = Socket::ERROR_OPNOTSUPP; + return -1; +} +uint32_t +RawSocketImpl::GetTxAvailable (void) const +{ + NS_LOG_FUNCTION (this); + return 0xffffffff; +} +int +RawSocketImpl::Send (Ptr p, uint32_t flags) +{ + NS_LOG_FUNCTION (this << p << flags); + InetSocketAddress to = InetSocketAddress (m_dst, m_protocol); + return SendTo (p, flags, to); +} +int +RawSocketImpl::SendTo (Ptr packet, uint32_t flags, const Address &toAddress) +{ + NS_LOG_FUNCTION (this << packet << flags << toAddress); + if (!InetSocketAddress::IsMatchingType (toAddress)) + { + m_err = Socket::ERROR_INVAL; + return -1; + } + if (m_shutdownSend) + { + return 0; + } + InetSocketAddress ad = InetSocketAddress::ConvertFrom (toAddress); + Ptr ipv4 = m_node->GetObject (); + Ipv4Address dst = ad.GetIpv4 (); + if (ipv4->GetRoutingProtocol ()) + { + Ipv4Header header; + packet->PeekHeader(header); + SocketErrno errno_ = ERROR_NOTERROR;//do not use errno as it is the standard C last error number + Ptr route; + uint32_t oif = 0; //specify non-zero if bound to a source address + route = ipv4->GetRoutingProtocol ()->RouteOutput (packet, header, oif, errno_); + if (route != 0) + { + NS_LOG_LOGIC ("Route exists"); + Ptr outDev = route->GetOutputDevice (); + int32_t interface = ipv4->GetInterfaceForDevice (outDev); + NS_ASSERT (interface >= 0); + Ptr outInterface = ipv4->GetInterface (interface); + NS_LOG_LOGIC ("Send via NetDevice ifIndex " << outDev->GetIfIndex () << " ipv4InterfaceIndex " << interface); + + NS_ASSERT (packet->GetSize () <= outInterface->GetDevice ()->GetMtu ()); + if (!route->GetGateway ().IsEqual (Ipv4Address ("0.0.0.0"))) + { + if (outInterface->IsUp ()) + { + NS_LOG_LOGIC ("Send to gateway " << route->GetGateway ()); + outInterface->Send (packet, route->GetGateway ()); + } + else + { + NS_LOG_LOGIC ("Dropping-- outgoing interface is down: " << route->GetGateway ()); + } + } + else + { + if (outInterface->IsUp ()) + { + NS_LOG_LOGIC ("Send to destination " << header.GetDestination ()); + outInterface->Send (packet, header.GetDestination ()); + } + else + { + NS_LOG_LOGIC ("Dropping-- outgoing interface is down: " << header.GetDestination ()); + } + } + } + else + { + NS_LOG_DEBUG ("dropped because no outgoing route."); + } + } + return 0; +} +uint32_t +RawSocketImpl::GetRxAvailable (void) const +{ + NS_LOG_FUNCTION (this); + uint32_t rx = 0; + for (std::list::const_iterator i = m_recv.begin (); i != m_recv.end (); ++i) + { + rx += (i->packet)->GetSize (); + } + return rx; +} +Ptr +RawSocketImpl::Recv (uint32_t maxSize, uint32_t flags) +{ + NS_LOG_FUNCTION (this << maxSize << flags); + Address tmp; + return RecvFrom (maxSize, flags, tmp); +} +Ptr +RawSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress) +{ + NS_LOG_FUNCTION (this << maxSize << flags << fromAddress); + if (m_recv.empty ()) + { + return 0; + } + struct Data data = m_recv.front (); + m_recv.pop_front (); + if (data.packet->GetSize () > maxSize) + { + Ptr first = data.packet->CreateFragment (0, maxSize); + data.packet->RemoveAtStart (maxSize); + m_recv.push_front (data); + return first; + } + InetSocketAddress inet = InetSocketAddress (data.fromIp, data.fromProtocol); + fromAddress = inet; + return data.packet; +} + +void +RawSocketImpl::SetProtocol (uint16_t protocol) +{ + NS_LOG_FUNCTION (this << protocol); + m_protocol = protocol; +} + +bool +RawSocketImpl::ForwardUp (Ptr p, Ipv4Header ipHeader, Ptr device) +{ + NS_LOG_FUNCTION (this << *p << ipHeader << device); + if (m_shutdownRecv) + { + return false; + } NS_LOG_LOGIC ("src = " << m_src << " dst = " << m_dst); + if ((m_src == Ipv4Address::GetAny () || ipHeader.GetDestination () == m_src) && (m_dst == Ipv4Address::GetAny () || ipHeader.GetSource () == m_dst) + && ipHeader.GetProtocol () == m_protocol) + { + Ptr copy = p->Copy (); + if (m_protocol == 1) + { + Icmpv4Header icmpHeader; + copy->PeekHeader (icmpHeader); + uint8_t type = icmpHeader.GetType (); + if (type < 32 && ((1 << type) & m_icmpFilter)) + { + // filter out icmp packet. + return false; + } + } + copy->AddHeader (ipHeader); + struct Data data; + data.packet = copy; + data.fromIp = ipHeader.GetSource (); + data.fromProtocol = ipHeader.GetProtocol (); + m_recv.push_back (data); + NotifyDataRecv (); + return true; + } + return false; +} + +} // namespace ns3 diff --git a/src/internet-stack/raw-socket-impl.h b/src/internet-stack/raw-socket-impl.h new file mode 100644 index 000000000..39249c84d --- /dev/null +++ b/src/internet-stack/raw-socket-impl.h @@ -0,0 +1,66 @@ +#ifndef IPV4_RAW_SOCKET_IMPL_H +#define IPV4_RAW_SOCKET_IMPL_H + +#include "ns3/socket.h" +#include "ns3/ipv4-header.h" +#include "ns3/ipv4-route.h" +#include + +namespace ns3 { + +class NetDevice; +class Node; + +class RawSocketImpl : public Socket +{ +public: + static TypeId GetTypeId (void); + + RawSocketImpl (); + + void SetNode (Ptr node); + + virtual enum Socket::SocketErrno GetErrno (void) const; + virtual Ptr GetNode (void) const; + virtual int Bind (const Address &address); + virtual int Bind (); + virtual int GetSockName (Address &address) const; + virtual int Close (void); + virtual int ShutdownSend (void); + virtual int ShutdownRecv (void); + virtual int Connect (const Address &address); + virtual int Listen (void); + virtual uint32_t GetTxAvailable (void) const; + virtual int Send (Ptr p, uint32_t flags); + virtual int SendTo (Ptr p, uint32_t flags, + const Address &toAddress); + virtual uint32_t GetRxAvailable (void) const; + virtual Ptr Recv (uint32_t maxSize, uint32_t flags); + virtual Ptr RecvFrom (uint32_t maxSize, uint32_t flags, + Address &fromAddress); + + void SetProtocol (uint16_t protocol); + bool ForwardUp (Ptr p, Ipv4Header ipHeader, Ptr device); +private: + virtual void DoDispose (void); + + struct Data { + Ptr packet; + Ipv4Address fromIp; + uint16_t fromProtocol; + }; + + enum Socket::SocketErrno m_err; + Ptr m_node; + Ipv4Address m_src; + Ipv4Address m_dst; + uint16_t m_protocol; + std::list m_recv; + bool m_shutdownSend; + bool m_shutdownRecv; + uint32_t m_icmpFilter; +}; + +} // namespace ns3 + +#endif /* IPV4_RAW_SOCKET_IMPL_H */ diff --git a/src/internet-stack/wscript b/src/internet-stack/wscript index 9d4ea3118..be1042b76 100644 --- a/src/internet-stack/wscript +++ b/src/internet-stack/wscript @@ -94,6 +94,7 @@ def build(bld): 'pending-data.cc', 'sequence-number.cc', 'rtt-estimator.cc', + 'raw-socket-impl.cc', 'ipv4-raw-socket-factory-impl.cc', 'ipv4-raw-socket-impl.cc', 'icmpv4.cc', diff --git a/src/routing/aodv/aodv-routing-protocol.cc b/src/routing/aodv/aodv-routing-protocol.cc index 1fbce885f..43b7f75d2 100644 --- a/src/routing/aodv/aodv-routing-protocol.cc +++ b/src/routing/aodv/aodv-routing-protocol.cc @@ -163,9 +163,16 @@ RoutingProtocol::RoutingProtocol () : NODE_TRAVERSAL_TIME (MilliSeconds (40)), ALLOWED_HELLO_LOSS (2), FREQUENCY (Seconds (0.5)), + BLACKLIST_TIMEOUT(Scalar(RREQ_RETRIES) * NET_TRAVERSAL_TIME), + /* BLACKLIST_TIMEOUT should be suitably increased if an expanding ring search is used. In such cases, it should be + * {[(TTL_THRESHOLD - TTL_START)/TTL_INCREMENT] + 1 + RREQ_RETRIES} *NET_TRAVERSAL_TIME. + * This is to account for possible additional route discovery attempts. + */ + NEXT_HOP_WAIT(NODE_TRAVERSAL_TIME + MilliSeconds (10)), m_broadcastID (0), m_seqNo (0), btimer (Timer::CANCEL_ON_DESTROY), htimer (Timer::CANCEL_ON_DESTROY), ntimer (Timer::CANCEL_ON_DESTROY), rtimer (Timer::CANCEL_ON_DESTROY), lrtimer (Timer::CANCEL_ON_DESTROY), m_routeRequestTimer (Timer::CANCEL_ON_DESTROY) + { NET_TRAVERSAL_TIME = Scalar (2 * NET_DIAMETER) * NODE_TRAVERSAL_TIME; BCAST_ID_SAVE = Scalar (2) * NET_TRAVERSAL_TIME; @@ -234,12 +241,8 @@ RoutingProtocol::Start () // Add local broadcast record to the routing table Ptr dev = m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (iface.GetLocal ())); - RoutingTableEntry rt (/*device=*/dev, /*dst=*/iface.GetBroadcast (), - /*know seqno=*/true, /*seqno=*/0, - /*iface=*/iface.GetLocal (), - /*hops=*/1, - /*next hop=*/iface.GetBroadcast (), - /*lifetime=*/Seconds (1e9)); // TODO use infty + RoutingTableEntry rt (/*device=*/dev, /*dst=*/iface.GetBroadcast (), /*know seqno=*/true, /*seqno=*/0, /*iface=*/iface.GetLocal (), + /*hops=*/1, /*next hop=*/iface.GetBroadcast (), /*lifetime=*/Seconds (1e9)); // TODO use infty m_routingTable.AddRoute (rt); } @@ -376,6 +379,7 @@ RoutingProtocol::SetIpv4 (Ptr ipv4) htimer.SetFunction (&RoutingProtocol::HelloTimerExpire, this); m_routeRequestTimer.SetFunction(&RoutingProtocol::RouteRequestTimerExpire, this); + htimer.SetDelay (HELLO_INTERVAL); btimer.SetDelay (BCAST_ID_SAVE); rtimer.SetDelay (FREQUENCY); @@ -506,20 +510,19 @@ void RoutingProtocol::RecvAodv (Ptr socket) { NS_LOG_FUNCTION (this); - Ptr packet; Address sourceAddress; packet = socket->RecvFrom (sourceAddress); InetSocketAddress inetSourceAddr = InetSocketAddress::ConvertFrom (sourceAddress); NS_ASSERT (inetSourceAddr.GetPort () == AODV_PORT); - Ipv4Address senderIfaceAddr = inetSourceAddr.GetIpv4 (); - Ipv4Address receiverIfaceAddr = m_socketAddresses[socket].GetLocal (); + Ipv4Address sender = inetSourceAddr.GetIpv4 (); + Ipv4Address receiver = m_socketAddresses[socket].GetLocal (); - NS_LOG_DEBUG ("AODV node " << this << " received a AODV packet from " << senderIfaceAddr << " to " << receiverIfaceAddr); - - UpdateRouteToNeighbor (senderIfaceAddr, receiverIfaceAddr); + NS_LOG_DEBUG ("AODV node " << this << " received a AODV packet from " << sender << " to " << receiver); + UpdateRouteToNeighbor (sender, receiver); + NS_LOG_LOGIC("xxx"); TypeHeader tHeader (AODVTYPE_RREQ); packet->RemoveHeader (tHeader); if (!tHeader.IsValid ()) @@ -532,21 +535,24 @@ RoutingProtocol::RecvAodv (Ptr socket) { case AODVTYPE_RREQ: { - RecvRequest (packet, receiverIfaceAddr, senderIfaceAddr, socket); + RecvRequest (packet, receiver, sender, socket); break; } case AODVTYPE_RREP: { - RecvReply (packet, receiverIfaceAddr, senderIfaceAddr); + RecvReply (packet, receiver, sender); break; } case AODVTYPE_RERR: { - RecvError (packet, senderIfaceAddr); + RecvError (packet, sender); break; } case AODVTYPE_RREP_ACK: - break; + { + RecvReplyAck(sender); + break; + } } } @@ -573,20 +579,19 @@ RoutingProtocol::UpdateRouteToNeighbor (Ipv4Address sender, Ipv4Address receiver if (!m_routingTable.LookupRoute (sender, toNeighbor)) { Ptr dev = m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver)); - RoutingTableEntry newEntry (/*device=*/dev, /*dst=*/sender, - /*know seqno=*/false, /*seqno=*/0, - /*iface=*/receiver, - /*hops=*/1, /*next hop=*/sender, - /*lifetime=*/Simulator::Now () + ACTIVE_ROUTE_TIMEOUT); + RoutingTableEntry newEntry (/*device=*/dev, /*dst=*/sender, /*know seqno=*/false, /*seqno=*/0, /*iface=*/receiver, + /*hops=*/1, /*next hop=*/sender,/*lifetime=*/Simulator::Now () + ACTIVE_ROUTE_TIMEOUT); m_routingTable.AddRoute (newEntry); } else { toNeighbor.SetFlag (RTF_UP); toNeighbor.SetValidSeqNo(false); - Time t = toNeighbor.GetLifeTime (); - if (t < Simulator::Now () + ACTIVE_ROUTE_TIMEOUT) + if (toNeighbor.GetLifeTime () < Simulator::Now () + ACTIVE_ROUTE_TIMEOUT) + { + toNeighbor.SetLifeTime (Simulator::Now () + ACTIVE_ROUTE_TIMEOUT); + } m_routingTable.Update (sender, toNeighbor); } } @@ -630,10 +635,8 @@ RoutingProtocol::RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address s if (!m_routingTable.LookupRoute (origin, toOrigin)) { Ptr dev = m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver)); - RoutingTableEntry newEntry (/*device=*/dev, /*dst=*/origin, /*validSeno=*/ - true, /*seqNo=*/rreqHeader.GetOriginSeqno (), - /*iface=*/receiver, /*hops=*/hop, /*nextHop*/src, - /*timeLife=*/Simulator::Now () + Scalar (2) * NET_TRAVERSAL_TIME - Scalar (2 * hop) * NODE_TRAVERSAL_TIME); + RoutingTableEntry newEntry (/*device=*/dev, /*dst=*/origin, /*validSeno=*/true, /*seqNo=*/rreqHeader.GetOriginSeqno (),/*iface=*/receiver, + /*hops=*/hop, /*nextHop*/src, /*timeLife=*/Simulator::Now () + Scalar (2) * NET_TRAVERSAL_TIME - Scalar (2 * hop) * NODE_TRAVERSAL_TIME); m_routingTable.AddRoute (newEntry); } else @@ -645,8 +648,11 @@ RoutingProtocol::RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address s toOrigin.SetOutputDevice (m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver))); toOrigin.SetHop (hop); Time minimalLifetime = Simulator::Now () + Scalar (2) * NET_TRAVERSAL_TIME - Scalar (2 * hop) * NODE_TRAVERSAL_TIME; + if (toOrigin.GetLifeTime () < minimalLifetime) + { toOrigin.SetLifeTime (minimalLifetime); + } m_routingTable.Update (origin, toOrigin); } @@ -718,6 +724,14 @@ RoutingProtocol::SendReply (RreqHeader const & rreqHeader, RoutingTableEntry con if (!rreqHeader.GetUnknownSeqno () && (rreqHeader.GetDstSeqno () == m_seqNo + 1)) m_seqNo++; RrepHeader rrepHeader ( /*prefixSize=*/0, /*hops=*/toOrigin.GetHop (), /*dst=*/rreqHeader.GetDst (), /*dstSeqNo=*/m_seqNo, /*origin=*/toOrigin.GetDestination (), /*lifeTime=*/MY_ROUTE_TIMEOUT); + // TODO when?? + rrepHeader.SetAckRequired(true); + RoutingTableEntry toNextHop; + m_routingTable.LookupRoute(toOrigin.GetNextHop (), toNextHop); + toNextHop.m_ackTimer.SetFunction(&RoutingProtocol::AckTimerExpire, this); + toNextHop.m_ackTimer.SetArguments(toNextHop.GetDestination(), BLACKLIST_TIMEOUT); + toNextHop.m_ackTimer.SetDelay(NEXT_HOP_WAIT); + Ptr packet = Create (); packet->AddHeader (rrepHeader); TypeHeader tHeader (AODVTYPE_RREP); @@ -757,17 +771,20 @@ RoutingProtocol::SendReplyByIntermediateNode (RoutingTableEntry & toDst, Routing } void -RoutingProtocol::SendRouteReplyAck(Ipv4Address neighbor, Ptr socket) +RoutingProtocol::SendReplyAck(Ipv4Address neighbor) { + NS_LOG_FUNCTION(this); RrepAckHeader h; TypeHeader typeHeader(AODVTYPE_RREP_ACK); Ptr packet = Create (); packet->AddHeader(h); packet->AddHeader(typeHeader); + RoutingTableEntry toNeighbor; + m_routingTable.LookupRoute(neighbor, toNeighbor); + Ptr socket = FindSocketWithInterfaceAddress(toNeighbor.GetInterface()); socket->SendTo (packet, 0, InetSocketAddress (neighbor, AODV_PORT)); } - void RoutingProtocol::RecvReply (Ptr p, Ipv4Address receiver, Ipv4Address sender) { @@ -836,7 +853,8 @@ RoutingProtocol::RecvReply (Ptr p, Ipv4Address receiver, Ipv4Address sen NS_LOG_LOGIC("add new route"); m_routingTable.AddRoute (newEntry); } - + // Acknowledge receipt of the RREP by sending a RREP-ACK message back + if(rrepHeader.GetAckRequired()) SendReplyAck(sender); if (receiver == rrepHeader.GetOrigin ()) { if (toDst.GetFlag () == RTF_IN_SEARCH) @@ -876,6 +894,13 @@ RoutingProtocol::RecvReply (Ptr p, Ipv4Address receiver, Ipv4Address sen } } +void +RoutingProtocol::RecvReplyAck(Ipv4Address neighbor) +{ + // TODO +} + + // TODO may be used for determining connectivity void RoutingProtocol::ProcessHello (RrepHeader const & rrepHeader, Ipv4Address receiverIfaceAddr) @@ -899,7 +924,9 @@ RoutingProtocol::ProcessHello (RrepHeader const & rrepHeader, Ipv4Address receiv else { if (toNeighbor.GetLifeTime () < Simulator::Now () + Scalar (ALLOWED_HELLO_LOSS) * HELLO_INTERVAL) + { toNeighbor.SetLifeTime (Simulator::Now () + Scalar (ALLOWED_HELLO_LOSS) * HELLO_INTERVAL); + } toNeighbor.SetSeqNo (rrepHeader.GetDstSeqno ()); toNeighbor.SetValidSeqNo (true); toNeighbor.SetFlag (RTF_UP); @@ -1021,6 +1048,19 @@ RoutingProtocol::LocalRepairTimerExpire () // TODO start local repair procedure } +void +RoutingProtocol::AckTimerExpire (Ipv4Address neighbor, Time blacklistTimeout) +{ + NS_LOG_FUNCTION(this); + m_routingTable.MarkLinkAsUinidirectional(neighbor, blacklistTimeout); +} + +void +RoutingProtocol::RoutingTableEntryTimerExpire(Ipv4Address dst) +{ + // TODO +} + void RoutingProtocol::SendHello () { diff --git a/src/routing/aodv/aodv-routing-protocol.h b/src/routing/aodv/aodv-routing-protocol.h index 4f383aff5..a48611694 100644 --- a/src/routing/aodv/aodv-routing-protocol.h +++ b/src/routing/aodv/aodv-routing-protocol.h @@ -93,6 +93,8 @@ private: Time MinHelloInterval; // (0.75 * HELLO_INTERVAL) Time FREQUENCY; Time NET_TRAVERSAL_TIME; // 2 * NODE_TRAVERSAL_TIME * NET_DIAMETER + Time BLACKLIST_TIMEOUT; + Time NEXT_HOP_WAIT; //\} /// \name Handle Broadcast sequence number cache @@ -213,6 +215,8 @@ private: void RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address src, Ptr socket); /// Receive RREP void RecvReply (Ptr p, Ipv4Address my ,Ipv4Address src); + /// receive RREP_ACK + void RecvReplyAck(Ipv4Address neighbor); /// Receive RERR from node with address src void RecvError (Ptr p, Ipv4Address src); //\} @@ -234,7 +238,7 @@ private: */ void SendReplyByIntermediateNode (RoutingTableEntry & toDst, RoutingTableEntry & toOrigin, bool gratRep, Ptr socket); /// Send RREP_ACK - void SendRouteReplyAck (Ipv4Address neighbor, Ptr socket); + void SendReplyAck (Ipv4Address neighbor); ///\name Send RERR //\{ void SendRerrWhenBreaksLinkToNextHop (Ipv4Address nextHop); @@ -258,6 +262,8 @@ private: void LocalRepairTimerExpire (); Timer m_routeRequestTimer; void RouteRequestTimerExpire(Ipv4Address dst); + void AckTimerExpire (Ipv4Address neighbor, Time blacklistTimeout); + void RoutingTableEntryTimerExpire(Ipv4Address dst); //\} }; diff --git a/src/routing/aodv/aodv-rtable.cc b/src/routing/aodv/aodv-rtable.cc index 8a6063819..df6166687 100644 --- a/src/routing/aodv/aodv-rtable.cc +++ b/src/routing/aodv/aodv-rtable.cc @@ -42,7 +42,9 @@ namespace aodv { RoutingTableEntry::RoutingTableEntry(Ptr dev, Ipv4Address dst, bool vSeqNo, u_int32_t seqNo, Ipv4Address iface, u_int16_t hops, Ipv4Address nextHop, Time lifetime) - : m_validSeqNo(vSeqNo), m_seqNo(seqNo), m_hops(hops), m_lifeTime(lifetime + Simulator::Now()), m_reqCount(0) + : m_validSeqNo(vSeqNo), m_seqNo(seqNo), m_hops(hops), m_lifeTime(lifetime + Simulator::Now()), + m_reqCount(0), m_blackListState(false), m_blackListTimeout(Simulator::Now()), + m_ackTimer(Timer::CANCEL_ON_DESTROY), lifeTimeTimer(Timer::CANCEL_ON_DESTROY) { m_ipv4Route = Create (); m_ipv4Route->SetDestination(dst); @@ -155,7 +157,7 @@ RoutingTableEntry::Print(std::ostream & os) const */ bool -RoutingTable::LookupRoute(Ipv4Address id, RoutingTableEntry & rt) +RoutingTable::LookupRoute(Ipv4Address id, RoutingTableEntry & rt) const { std::map::const_iterator i = m_ipv4AddressEntry.find(id); if (i == m_ipv4AddressEntry.end()) return false; @@ -241,6 +243,17 @@ RoutingTable::Purge(Time badLinkLifetime) } } +bool +RoutingTable::MarkLinkAsUinidirectional (Ipv4Address neighbor, Time blacklistTimeout) +{ + std::map::iterator i = m_ipv4AddressEntry.find(neighbor); + if (i == m_ipv4AddressEntry.end()) return false; + i->second.SetUnidirectional (true); + i->second.SetBalcklistTimeout(blacklistTimeout); + return true; +} + + void RoutingTable::Print(std::ostream &os) const { diff --git a/src/routing/aodv/aodv-rtable.h b/src/routing/aodv/aodv-rtable.h index 960427836..5c1b774cc 100644 --- a/src/routing/aodv/aodv-rtable.h +++ b/src/routing/aodv/aodv-rtable.h @@ -123,6 +123,10 @@ public: void SetRreqCnt(uint8_t n) { m_reqCount = n; } uint8_t GetRreqCnt() const { return m_reqCount; } void IncrementRreqCnt() { m_reqCount++; } + bool IsInBlacklist() const { return m_blackListState; } + void SetUnidirectional(bool u) { m_blackListState = u; } + void SetBalcklistTimeout (Time t) { m_blackListTimeout = t; } + Time GetBlacklistTimeout () { return m_blackListTimeout; } //\} /** @@ -165,6 +169,14 @@ private: Time m_routeRequestTimout; /// Number of route requests uint8_t m_reqCount; + /// Indicate if this entry is in "blacklist" + bool m_blackListState; + Time m_blackListTimeout; +public: + /// RREP_ACK timer + Timer m_ackTimer; + /// LifeTime timer of this entry + Timer lifeTimeTimer; }; /** @@ -194,7 +206,7 @@ public: * \param rt entry with destination address dst, if exists * \return true on success */ - bool LookupRoute(Ipv4Address dst, RoutingTableEntry & rt); + bool LookupRoute(Ipv4Address dst, RoutingTableEntry & rt) const; /// Update routing table bool Update(Ipv4Address dst, RoutingTableEntry & rt); /// Set routing table entry flags @@ -213,6 +225,11 @@ public: void InvalidateRoutesWithDst(std::map const & unreachable, Time badLinkLifetime); /// Delete all outdated entries and invalidate valid entry if Lifetime is expired void Purge(Time badLinkLifetime); + /** Mark entry as unidirectional (e.g. add this neighbor to "blacklist" for blacklistTimeout period) + * \param neighbor - neighbor address link to which assumed to be unidirectional + * \return true on success + */ + bool MarkLinkAsUinidirectional(Ipv4Address neighbor, Time blacklistTimeout); /// Print routing table void Print(std::ostream &os) const;