From ef51173b0f951966559283da4c09e75925c4dc80 Mon Sep 17 00:00:00 2001 From: Daniel Lertpratchya Date: Fri, 13 Dec 2013 10:28:25 -0500 Subject: [PATCH] [doxygen] dsr module (fix only trivial warnings) --- src/dsr/model/dsr-errorbuff.h | 56 +++-- src/dsr/model/dsr-fs-header.h | 21 +- src/dsr/model/dsr-gratuitous-reply-table.h | 32 +-- src/dsr/model/dsr-maintain-buff.h | 68 ++++-- src/dsr/model/dsr-network-queue.h | 78 +++++- src/dsr/model/dsr-option-header.h | 45 ++-- src/dsr/model/dsr-options.cc | 2 +- src/dsr/model/dsr-options.h | 263 +++++---------------- src/dsr/model/dsr-passive-buff.h | 70 +++--- src/dsr/model/dsr-rcache.h | 65 ++--- src/dsr/model/dsr-routing.h | 76 ++++-- src/dsr/model/dsr-rreq-table.h | 222 ++++++++++++----- src/dsr/model/dsr-rsendbuff.h | 97 ++++++-- 13 files changed, 621 insertions(+), 474 deletions(-) diff --git a/src/dsr/model/dsr-errorbuff.h b/src/dsr/model/dsr-errorbuff.h index f7ec9c0a7..cbd182542 100644 --- a/src/dsr/model/dsr-errorbuff.h +++ b/src/dsr/model/dsr-errorbuff.h @@ -45,7 +45,16 @@ namespace dsr { class ErrorBuffEntry { public: - // / c-tor + /** + * Create an ErrorBuffEntry with the given parameters. + * + * \param pa packet + * \param d IPv4 address of the destination + * \param s IPv4 address of the source + * \param n IPv4 address of the next hop + * \param exp expiration time + * \param p protocol number + */ ErrorBuffEntry (Ptr pa = 0, Ipv4Address d = Ipv4Address (), Ipv4Address s = Ipv4Address (), Ipv4Address n = Ipv4Address (), Time exp = Simulator::Now (), uint8_t p = 0) : m_packet (pa), @@ -58,13 +67,14 @@ public: } /** * Compare send buffer entries + * \param o another ErrorBuffEntry * \return true if equal */ bool operator== (ErrorBuffEntry const & o) const { return ((m_packet == o.m_packet) && (m_source == o.m_source) && (m_nextHop == o.m_nextHop) && (m_dst == o.m_dst) && (m_expire == o.m_expire)); } - // /\name Fields + ///\name Fields // \{ Ptr GetPacket () const { @@ -116,17 +126,17 @@ public: } // \} private: - // / Data packet + /// Data packet Ptr m_packet; - // / Destination address + /// Destination address Ipv4Address m_dst; - // / Source address + /// Source address Ipv4Address m_source; - // / Nexthop address + /// Nexthop address Ipv4Address m_nextHop; - // / Expire time for queue entry + /// Expire time for queue entry Time m_expire; - // / The protocol number + /// The protocol number uint8_t m_protocol; }; @@ -138,21 +148,23 @@ private: class ErrorBuffer { public: - // / Default c-tor + /** + * Default constructor + */ ErrorBuffer () { } - // / Push entry in queue, if there is no entry with the same packet and destination address in queue. + /// Push entry in queue, if there is no entry with the same packet and destination address in queue. bool Enqueue (ErrorBuffEntry & entry); - // / Return first found (the earliest) entry for given destination + /// Return first found (the earliest) entry for given destination bool Dequeue (Ipv4Address dst, ErrorBuffEntry & entry); - // / Remove all packets with the error link + /// Remove all packets with the error link void DropPacketForErrLink (Ipv4Address source, Ipv4Address nextHop); - // / Finds whether a packet with destination dst exists in the queue + /// Finds whether a packet with destination dst exists in the queue bool Find (Ipv4Address dst); - // / Number of entries + /// Number of entries uint32_t GetSize (); - // /\name Fields + ///\name Fields // \{ uint32_t GetMaxQueueLen () const { @@ -178,19 +190,19 @@ public: } private: - // / The send buffer to cache unsent packet + /// The send buffer to cache unsent packet std::vector m_errorBuffer; - // / Remove all expired entries + /// Remove all expired entries void Purge (); - // / Notify that packet is dropped from queue by timeout + /// Notify that packet is dropped from queue by timeout void Drop (ErrorBuffEntry en, std::string reason); - // / Notify that packet is dropped from queue by timeout + /// Notify that packet is dropped from queue by timeout void DropLink (ErrorBuffEntry en, std::string reason); - // / The maximum number of packets that we allow a routing protocol to buffer. + /// The maximum number of packets that we allow a routing protocol to buffer. uint32_t m_maxLen; - // / The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. + /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_errorBufferTimeout; - // / Check if the send buffer entry is the same or not + /// Check if the send buffer entry is the same or not static bool LinkEqual (ErrorBuffEntry en, const std::vector link) { return ((en.GetSource () == link[0]) && (en.GetNextHop () == link[1])); diff --git a/src/dsr/model/dsr-fs-header.h b/src/dsr/model/dsr-fs-header.h index 65382d6d4..b1420dc30 100644 --- a/src/dsr/model/dsr-fs-header.h +++ b/src/dsr/model/dsr-fs-header.h @@ -99,7 +99,7 @@ public: virtual ~DsrFsHeader (); /** * \brief Set the "Next header" field. - * \param nextHeader the next header number + * \param protocol the next header number */ void SetNextHeader (uint8_t protocol); /** @@ -109,7 +109,7 @@ public: uint8_t GetNextHeader () const; /** * brief Set the message type of the header. - * \param message type the message type of the header + * \param messageType the message type of the header */ void SetMessageType (uint8_t messageType); /** @@ -118,23 +118,23 @@ public: */ uint8_t GetMessageType () const; /** - * brief Set the source id of the header. - * \param source id the source id of the header + * brief Set the source ID of the header. + * \param sourceId the source ID of the header */ void SetSourceId (uint16_t sourceId); /** - * brief Get the source id of the header. - * \return source id the source id of the header + * brief Get the source ID of the header. + * \return source ID the source ID of the header */ uint16_t GetSourceId () const; /** - * brief Set the dest id of the header. - * \param dest id the dest id of the header + * brief Set the dest ID of the header. + * \param destId the destination ID of the header */ void SetDestId (uint16_t destId); /** - * brief Get the dest id of the header. - * \return dest id the dest id of the header + * brief Get the dest ID of the header. + * \return dest ID the dest ID of the header */ uint16_t GetDestId () const; /** @@ -257,6 +257,7 @@ private: /** * \brief Calculate padding. * \param alignment alignment + * \return the number of bytes required to pad */ uint32_t CalculatePad (DsrOptionHeader::Alignment alignment) const; /** diff --git a/src/dsr/model/dsr-gratuitous-reply-table.h b/src/dsr/model/dsr-gratuitous-reply-table.h index 4073386fb..3d8468948 100644 --- a/src/dsr/model/dsr-gratuitous-reply-table.h +++ b/src/dsr/model/dsr-gratuitous-reply-table.h @@ -65,49 +65,41 @@ struct GraReplyEntry class GraReply : public Object { public: - // / c-tor - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); - /** - * \brief Constructor. - */ + GraReply (); - /** - * \brief Destructor. - */ virtual ~GraReply (); - // / Set the gratuitous reply table size + + /// Set the gratuitous reply table size void SetGraTableSize (uint32_t g) { GraReplyTableSize = g; } - // / Get the gratuitous reply table size + /// Get the gratuitous reply table size uint32_t GetGraTableSize () const { return GraReplyTableSize; } - // / Add a new gratuitous reply entry + /// Add a new gratuitous reply entry bool AddEntry (GraReplyEntry & graTableEntry); - // / Update the route entry if found, create a new one if not + /// Update the route entry if found, create a new one if not bool FindAndUpdate (Ipv4Address replyTo, Ipv4Address replyFrom, Time gratReplyHoldoff); - // / Remove all expired entries + /// Remove all expired entries void Purge (); - // / Remove all entries + /// Remove all entries void Clear () { m_graReply.clear (); } private: - // / Vector of entries + /// Vector of entries std::vector m_graReply; - // / The max # of gratuitous reply entries to hold + /// The max # of gratuitous reply entries to hold uint32_t GraReplyTableSize; - // / Check if the entry is expired or not + /// Check if the entry is expired or not struct IsExpired { bool operator() (const struct GraReplyEntry & b) const diff --git a/src/dsr/model/dsr-maintain-buff.h b/src/dsr/model/dsr-maintain-buff.h index 53486908b..2ee1cb583 100644 --- a/src/dsr/model/dsr-maintain-buff.h +++ b/src/dsr/model/dsr-maintain-buff.h @@ -53,6 +53,7 @@ struct LinkKey /** * Compare maintain Buffer entries + * \param o * \return true if equal */ bool operator < (LinkKey const & o) const @@ -73,6 +74,7 @@ struct NetworkKey /** * Compare maintain Buffer entries + * \param o * \return true if equal */ bool operator < (NetworkKey const & o) const @@ -92,6 +94,7 @@ struct PassiveKey /** * Compare maintain Buffer entries + * \param o * \return true if equal */ bool operator < (PassiveKey const & o) const @@ -109,7 +112,18 @@ struct PassiveKey class MaintainBuffEntry { public: - // / c-tor + /** + * Construct a MaintainBuffEntry with the given parameters + * + * \param pa packet + * \param us our IPv4 address + * \param n next hop IPv4 address + * \param s IPv4 address of the source + * \param dst IPv4 address of the destination + * \param ackId ACK ID + * \param segs number of segments left + * \param exp expiration time + */ MaintainBuffEntry (Ptr pa = 0, Ipv4Address us = Ipv4Address (), Ipv4Address n = Ipv4Address (), Ipv4Address s = Ipv4Address (), Ipv4Address dst = Ipv4Address (), uint16_t ackId = 0, uint8_t segs = 0, Time exp = Simulator::Now ()) @@ -124,7 +138,7 @@ public: { } - // /\name Fields + ///\name Fields // \{ Ptr GetPacket () const { @@ -192,21 +206,21 @@ public: } // \} private: - // / Data packet + /// Data packet Ptr m_packet; - // / Our own ip address + /// Our own ip address Ipv4Address m_ourAdd; - // / Next hop Ip address + /// Next hop Ip address Ipv4Address m_nextHop; - // / The source address + /// The source address Ipv4Address m_src; - // / The destination address + /// The destination address Ipv4Address m_dst; - // / The data ack id + /// The data ack id uint16_t m_ackId; - // / The segments left field + /// The segments left field uint8_t m_segsLeft; - // / Expire time for queue entry + /// Expire time for queue entry Time m_expire; }; /** @@ -217,21 +231,23 @@ private: class MaintainBuffer { public: - // / Default c-tor + /** + * Default constructor + */ MaintainBuffer () { } - // / Push entry in queue, if there is no entry with the same packet and destination address in queue. + /// Push entry in queue, if there is no entry with the same packet and destination address in queue. bool Enqueue (MaintainBuffEntry & entry); - // / Return first found (the earliest) entry for given destination + /// Return first found (the earliest) entry for given destination bool Dequeue (Ipv4Address dst, MaintainBuffEntry & entry); - // / Remove all packets with destination IP address dst + /// Remove all packets with destination IP address dst void DropPacketWithNextHop (Ipv4Address nextHop); - // / Finds whether a packet with destination dst exists in the queue + /// Finds whether a packet with destination dst exists in the queue bool Find (Ipv4Address nextHop); - // / Number of entries + /// Number of entries uint32_t GetSize (); - // /\name Fields + ///\name Fields // \{ uint32_t GetMaxQueueLen () const { @@ -249,27 +265,27 @@ public: { m_maintainBufferTimeout = t; } - // / Verify if all the elements in the maintainence buffer entry is the same + /// Verify if all the elements in the maintainence buffer entry is the same bool AllEqual (MaintainBuffEntry & entry); - // / Verify if the maintain buffer entry is the same in every field for link ack + /// Verify if the maintain buffer entry is the same in every field for link ack bool LinkEqual (MaintainBuffEntry & entry); - // / Verify if the maintain buffer entry is the same in every field for network ack + /// Verify if the maintain buffer entry is the same in every field for network ack bool NetworkEqual (MaintainBuffEntry & entry); - // / Verify if the maintain buffer entry is the same in every field for promiscuous ack + /// Verify if the maintain buffer entry is the same in every field for promiscuous ack bool PromiscEqual (MaintainBuffEntry & entry); // \} private: - // / The vector of maintain buffer entries + /// The vector of maintain buffer entries std::vector m_maintainBuffer; std::vector m_allNetworkKey; - // / Remove all expired entries + /// Remove all expired entries void Purge (); - // / The maximum number of packets that we allow a routing protocol to buffer. + /// The maximum number of packets that we allow a routing protocol to buffer. uint32_t m_maxLen; - // / The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. + /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_maintainBufferTimeout; - // / Verify if the maintain buffer is equal or not + /// Verify if the maintain buffer is equal or not static bool IsEqual (MaintainBuffEntry en, const Ipv4Address nextHop) { return (en.GetNextHop () == nextHop); diff --git a/src/dsr/model/dsr-network-queue.h b/src/dsr/model/dsr-network-queue.h index 58124f175..a0f085279 100644 --- a/src/dsr/model/dsr-network-queue.h +++ b/src/dsr/model/dsr-network-queue.h @@ -53,7 +53,15 @@ enum DsrMessageType class DsrNetworkQueueEntry { public: - /// c-tor + /** + * Construct a DsrNetworkQueueEntry with the given parameters + * + * \param pa packet + * \param s IPv4 address of the source + * \param n IPv4 address of the next hop node + * \param exp expiration time + * \param r Route + */ DsrNetworkQueueEntry (Ptr pa = 0, Ipv4Address s = Ipv4Address (), Ipv4Address n = Ipv4Address (), Time exp = Simulator::Now (), Ptr r = 0) : m_packet (pa), @@ -65,6 +73,7 @@ public: } /** * Compare send buffer entries + * \param o * \return true if equal */ bool operator== (DsrNetworkQueueEntry const & o) const @@ -130,21 +139,69 @@ class DsrNetworkQueue : public Object { public: static TypeId GetTypeId (void); - /// Default c-tor + DsrNetworkQueue (); + /** + * Construct a DsrNetworkQueue with the given + * maximum length and maximum delay. + * + * \param maxLen Maximum queue size + * \param maxDelay Maximum entry lifetime in the queue + */ DsrNetworkQueue (uint32_t maxLen, Time maxDelay); ~DsrNetworkQueue (); - /// Push entry in queue, if there is no entry with the same packet and destination address in queue. + + /** + * Push entry in queue, if there is no entry with the same + * packet and destination address in queue. + * + * \param entry packet entry + * \return true if the given entry was put in the queue, + * false otherwise + */ bool Enqueue (DsrNetworkQueueEntry & entry); - /// Return first found (the earliest) entry for given destination + /** + * Return first found (the earliest) entry for given destination + * + * \param entry pointer to the return entry + * \return true if an entry is returned, + * false otherwise + */ bool Dequeue (DsrNetworkQueueEntry & entry); - /// Number of entries + /** + * Number of entries + * + * \return the current queue size/length + */ uint32_t GetSize (); + /** + * Set the maximum queue size + * + * \param maxSize the maximum queue size + */ void SetMaxNetworkSize (uint32_t maxSize); + /** + * Set the maximum entry lifetime in the queue + * + * \param delay the maximum entry lifetime + */ void SetMaxNetworkDelay (Time delay); + /** + * Return the maximum queue size + * + * \return the maximum queue size + */ uint32_t GetMaxNetworkSize (void) const; + /** + * Return the maximum entry lifetime for this queue + * + * \return the maximum entry lifetime for this queue + */ Time GetMaxNetworkDelay (void) const; + /** + * Clear the queue + */ void Flush (void); std::vector & GetQueue () @@ -153,11 +210,14 @@ public: } private: + /** + * Clean the queue by removing entries that exceeded lifetime. + */ void Cleanup (void); - std::vector m_dsrNetworkQueue; - uint32_t m_size; - uint32_t m_maxSize; - Time m_maxDelay; + std::vector m_dsrNetworkQueue; //!< Queue (vector) of entries + uint32_t m_size; //!< Current queue size + uint32_t m_maxSize; //!< Maximum queue size + Time m_maxDelay; //!< Maximum entry lifetime }; } // namespace dsr diff --git a/src/dsr/model/dsr-option-header.h b/src/dsr/model/dsr-option-header.h index 1dd4f6d77..a61ad2b0c 100644 --- a/src/dsr/model/dsr-option-header.h +++ b/src/dsr/model/dsr-option-header.h @@ -339,7 +339,7 @@ public: Ipv4Address GetNodeAddress (uint8_t index) const; /** * \brief Set the request id number. - * \param the identification number + * \param identification the identification number */ void SetId (uint16_t identification); /** @@ -589,7 +589,7 @@ public: virtual ~DsrOptionSRHeader (); /* * \brief Set the number of segments left to send - * \param The segments left + * \param segmentsLeft The segments left */ void SetSegmentsLeft (uint8_t segmentsLeft); /* @@ -631,7 +631,7 @@ public: Ipv4Address GetNodeAddress (uint8_t index) const; /* * \brief Set the salvage value for a packet - * \param The salvage value of the packet + * \param salvage The salvage value of the packet */ void SetSalvage (uint8_t salvage); /* @@ -715,7 +715,7 @@ private: \endverbatim */ -// / Error type +/// Error type enum ErrorType { NODE_UNREACHABLE = 1, // !< NODE_UNREACHABLE @@ -746,7 +746,7 @@ public: virtual ~DsrOptionRerrHeader (); /** * \brief Set the route error type - * \param The error type + * \param errorType The error type */ void SetErrorType (uint8_t errorType); /** @@ -756,7 +756,7 @@ public: uint8_t GetErrorType () const; /** * \brief Set the route error source address - * \param The error source address + * \param errorSrcAddress The error source address */ virtual void SetErrorSrc (Ipv4Address errorSrcAddress); /** @@ -770,12 +770,12 @@ public: virtual void SetSalvage (uint8_t salvage); /** * \brief Get the salvage value of the packet - * \param The salvage value of the packet + * \return The salvage value of the packet */ virtual uint8_t GetSalvage () const; /** * \brief Set the error destination ip address - * \param The error destination address + * \param errorDstAddress The error destination address */ virtual void SetErrorDst (Ipv4Address errorDstAddress); /** @@ -891,7 +891,7 @@ public: virtual ~DsrOptionRerrUnreachHeader (); /** * \brief Set the route error source address - * \param The error source address + * \param errorSrcAddress The error source address */ virtual void SetErrorSrc (Ipv4Address errorSrcAddress); /** @@ -905,12 +905,12 @@ public: virtual void SetSalvage (uint8_t salvage); /** * \brief Get the salvage value of the packet - * \param The salvage value of the packet + * \return The salvage value of the packet */ virtual uint8_t GetSalvage () const; /** * \brief Set the error destination ip address - * \param The error destination address + * \param errorDstAddress The error destination address */ virtual void SetErrorDst (Ipv4Address errorDstAddress); /** @@ -920,7 +920,7 @@ public: virtual Ipv4Address GetErrorDst () const; /** * \brief Set the unreachable node ip address - * \param The unreachable ip address + * \param unreachNode The unreachable ip address */ void SetUnreachNode (Ipv4Address unreachNode); /** @@ -930,7 +930,7 @@ public: Ipv4Address GetUnreachNode () const; /** * \brief Set the unreachable node ip address - * \param The unreachable ip address + * \param originalDst The unreachable ip address */ void SetOriginalDst (Ipv4Address originalDst); /** @@ -1047,7 +1047,7 @@ public: virtual ~DsrOptionRerrUnsupportHeader (); /** * \brief Set the route error source address - * \param The error source address + * \param errorSrcAddress The error source address */ virtual void SetErrorSrc (Ipv4Address errorSrcAddress); /** @@ -1057,16 +1057,17 @@ public: virtual Ipv4Address GetErrorSrc () const; /** * \brief Set the salvage value of the packet + * \param salvage the salvage value */ virtual void SetSalvage (uint8_t salvage); /** * \brief Get the salvage value of the packet - * \param The salvage value of the packet + * \return The salvage value of the packet */ virtual uint8_t GetSalvage () const; /** * \brief Set the error destination ip address - * \param The error destination address + * \param errorDstAddress The error destination address */ virtual void SetErrorDst (Ipv4Address errorDstAddress); /** @@ -1076,7 +1077,7 @@ public: virtual Ipv4Address GetErrorDst () const; /** * \brief Set the unsupported option type value - * \param The unsupported option type value + * \param optionType The unsupported option type value */ void SetUnsupported (uint16_t optionType); /** @@ -1175,7 +1176,7 @@ public: virtual ~DsrOptionAckReqHeader (); /** * \brief Set the Ack request id number. - * \param the identification number + * \param identification the identification number */ void SetAckId (uint16_t identification); /** @@ -1212,7 +1213,7 @@ public: virtual Alignment GetAlignment () const; private: - /* + /** * The identification field */ uint16_t m_identification; @@ -1262,7 +1263,7 @@ public: virtual ~DsrOptionAckHeader (); /** * \brief Set the Ack id number. - * \param the identification number + * \param identification the identification number */ void SetAckId (uint16_t identification); /** @@ -1272,7 +1273,7 @@ public: uint16_t GetAckId () const; /** * \brief Set Error source ip address. - * \param The real source address + * \param realSrcAddress The real source address */ void SetRealSrc (Ipv4Address realSrcAddress); /** @@ -1282,7 +1283,7 @@ public: Ipv4Address GetRealSrc () const; /** * \brief Set Error source ip address. - * \param The real dst address + * \param realDstAddress The real dst address */ void SetRealDst (Ipv4Address realDstAddress); /** diff --git a/src/dsr/model/dsr-options.cc b/src/dsr/model/dsr-options.cc index d3c4e1a8e..027c756e3 100644 --- a/src/dsr/model/dsr-options.cc +++ b/src/dsr/model/dsr-options.cc @@ -1562,7 +1562,7 @@ uint8_t DsrOptionRerr::DoSendError (Ptr p, DsrOptionRerrUnreachHeader &r newSourceRoute.SetNodesAddress (nodeList); nextAddress = newSourceRoute.GetNodeAddress (nextAddressIndex); - // / to test if the next address is multicast or not + /// to test if the next address is multicast or not if (nextAddress.IsMulticast () || targetAddress.IsMulticast ()) { m_dropTrace (p); diff --git a/src/dsr/model/dsr-options.h b/src/dsr/model/dsr-options.h index 276de0e40..4f43f3dd4 100644 --- a/src/dsr/model/dsr-options.h +++ b/src/dsr/model/dsr-options.h @@ -104,37 +104,58 @@ public: Ptr GetNode () const; /** * \brief Search for the ipv4 address in the node list. + * + * \param ipv4Address IPv4 address to search for + * \param destAddress IPv4 address in the list that we begin the search + * \param nodeList List of IPv4 addresses * \return true if contain ip address */ bool ContainAddressAfter (Ipv4Address ipv4Address, Ipv4Address destAddress, std::vector &nodeList); /** * \brief Cut the route from ipv4Address to the end of the route vector + * + * \param ipv4Address the address to begin cutting + * \param nodeList List of IPv4 addresses * \return the vector after the route cut */ std::vector CutRoute (Ipv4Address ipv4Address, std::vector &nodeList); /** - * \brief Set the route to use for data packets + * \brief Set the route to use for data packets, + * used by the option headers when sending data/control packets + * + * \param nextHop IPv4 address of the next hop + * \param srcAddress IPv4 address of the source * \return the route - * \used by the option headers when sending data/control packets */ virtual Ptr SetRoute (Ipv4Address nextHop, Ipv4Address srcAddress); /** * \brief Reverse the routes. + * + * \param vec List of IPv4 addresses * \return true if successfully reversed */ bool ReverseRoutes (std::vector& vec); /** * \brief Search for the next hop in the route + * + * \param ipv4Address the IPv4 address of the node we are looking for its next hop address + * \param vec List of IPv4 addresses * \return the next hop address if found */ Ipv4Address SearchNextHop (Ipv4Address ipv4Address, std::vector& vec); /** * \brief Reverse search for the next hop in the route + * + * \param ipv4Address the IPv4 address of the node we are looking for its next hop address + * \param vec List of IPv4 addresses * \return the previous next hop address if found */ Ipv4Address ReverseSearchNextHop (Ipv4Address ipv4Address, std::vector& vec); /** * \brief Reverse search for the next two hop in the route + * + * \param ipv4Address the IPv4 address of the node we are looking for its next two hop address + * \param vec List of IPv4 addresses * \return the previous next two hop address if found */ Ipv4Address ReverseSearchNextTwoHop (Ipv4Address ipv4Address, std::vector& vec); @@ -144,34 +165,46 @@ public: void PrintVector (std::vector& vec); /** * \brief Check if the two vectors contain duplicate or not + * + * \param vec the first list of IPv4 addresses + * \param vec2 the second list of IPv4 addresses * \return true if contains duplicate */ bool IfDuplicates (std::vector& vec, std::vector& vec2); /** * \brief Check if the route already contains the node ip address + * + * \param ipv4Address the IPv4 address that we are looking for + * \param vec List of IPv4 addresses * \return true if it already exists */ bool CheckDuplicates (Ipv4Address ipv4Address, std::vector& vec); - /* + /** * \brief Remove the duplicates from the route + * + * \param vec List of IPv4 addresses to be clean * \return the route after route shorten */ void RemoveDuplicates (std::vector& vec); /** * \brief Schedule the intermediate node route request broadcast - * \param the original packet - * \param rrepHeader The rrep header + * \param packet the original packet + * \param nodeList The list of IPv4 addresses * \param source address * \param destination address */ void ScheduleReply (Ptr &packet, std::vector &nodeList, Ipv4Address &source, Ipv4Address &destination); /** * \brief Get the node id with Ipv4Address + * + * \param address IPv4 address to look for ID * \return the id of the node */ uint32_t GetIDfromIP (Ipv4Address address); /** * \brief Get the node object with Ipv4Address + * + * \param ipv4Address IPv4 address of the node * \return the object of the node */ Ptr GetNodeWithAddress (Ipv4Address ipv4Address); @@ -181,9 +214,12 @@ public: * Called from DsrRouting::Receive. * \param packet the packet * \param dsrP the clean packet with payload + * \param ipv4Address the IPv4 address + * \param source IPv4 address of the source * \param ipv4Header the IPv4 header of packet received * \param protocol the protocol number of the up layer * \param isPromisc if the packet must be dropped + * \param promiscSource IPv4 address * \return the processed size */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource) = 0; @@ -245,35 +281,13 @@ public: * \brief Pad1 option number. */ static const uint8_t OPT_NUMBER = 224; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); - /** - * \brief Constructor. - */ + DsrOptionPad1 (); - /** - * \brief Destructor. - */ virtual ~DsrOptionPad1 (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); }; @@ -288,35 +302,13 @@ public: * \brief PadN option number. */ static const uint8_t OPT_NUMBER = 0; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); - /** - * \brief Constructor. - */ + DsrOptionPadn (); - /** - * \brief Destructor. - */ virtual ~DsrOptionPadn (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); }; @@ -331,10 +323,7 @@ public: * \brief Rreq option number. */ static const uint8_t OPT_NUMBER = 1; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); /** * \brief Get the instance type ID. @@ -349,22 +338,8 @@ public: * \brief Destructor. */ virtual ~DsrOptionRreq (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); private: @@ -389,40 +364,18 @@ public: * \brief Router alert option number. */ static const uint8_t OPT_NUMBER = 2; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); /** * \brief Get the instance type ID. * \return instance type ID */ virtual TypeId GetInstanceTypeId () const; - /** - * \brief Constructor. - */ + DsrOptionRrep (); - /** - * \brief Destructor. - */ virtual ~DsrOptionRrep (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); private: @@ -447,40 +400,18 @@ public: * \brief Source Route option number. */ static const uint8_t OPT_NUMBER = 96; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); /** * \brief Get the instance type ID. * \return instance type ID */ virtual TypeId GetInstanceTypeId () const; - /** - * \brief Constructor. - */ + DsrOptionSR (); - /** - * \brief Destructor. - */ virtual ~DsrOptionSR (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); private: @@ -501,40 +432,18 @@ public: * \brief Dsr Route Error option number. */ static const uint8_t OPT_NUMBER = 3; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); /** * \brief Get the instance type ID. * \return instance type ID */ virtual TypeId GetInstanceTypeId () const; - /** - * \brief Constructor. - */ + DsrOptionRerr (); - /** - * \brief Destructor. - */ virtual ~DsrOptionRerr (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); /** * \brief Do Send error message @@ -570,40 +479,18 @@ public: * \brief Dsr ack request option number. */ static const uint8_t OPT_NUMBER = 160; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); /** * \brief Get the instance type ID. * \return instance type ID */ virtual TypeId GetInstanceTypeId () const; - /** - * \brief Constructor. - */ + DsrOptionAckReq (); - /** - * \brief Destructor. - */ virtual ~DsrOptionAckReq (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); private: @@ -628,40 +515,18 @@ public: * \brief The Dsr Ack option number. */ static const uint8_t OPT_NUMBER = 32; - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); /** * \brief Get the instance type ID. * \return instance type ID */ virtual TypeId GetInstanceTypeId () const; - /** - * \brief Constructor. - */ + DsrOptionAck (); - /** - * \brief Destructor. - */ virtual ~DsrOptionAck (); - /** - * \brief Get the option number. - * \return option number - */ + virtual uint8_t GetOptionNumber () const; - /** - * \brief Process method - * - * Called from DsrRouting::Receive. - * \param packet the packet - * \param dsrP the clean packet with payload - * \param ipv4Header the IPv4 header of packet received - * \param protocol the protocol number of the up layer - * \param isPromisc if the packet must be dropped - * \return the processed size - */ virtual uint8_t Process (Ptr packet, Ptr dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource); private: diff --git a/src/dsr/model/dsr-passive-buff.h b/src/dsr/model/dsr-passive-buff.h index fa3e8226d..0830c023c 100644 --- a/src/dsr/model/dsr-passive-buff.h +++ b/src/dsr/model/dsr-passive-buff.h @@ -45,7 +45,19 @@ namespace dsr { class PassiveBuffEntry { public: - // / c-tor + /** + * Construct a PassiveBuffEntry with the given parameters + * + * \param pa packet + * \param d IPv4 address of the destination + * \param s IPv4 address of the source + * \param n IPv4 address of the next hop node + * \param i ID + * \param f fragment offset + * \param seg number of segments left + * \param exp expiration time + * \param p protocol number + */ PassiveBuffEntry (Ptr pa = 0, Ipv4Address d = Ipv4Address (), Ipv4Address s = Ipv4Address (), Ipv4Address n = Ipv4Address (), uint16_t i = 0, uint16_t f = 0, uint8_t seg = 0, Time exp = Simulator::Now (), uint8_t p = 0) @@ -68,7 +80,7 @@ public: { return ((m_packet == o.m_packet) && (m_source == o.m_source) && (m_nextHop == o.m_nextHop) && (m_dst == o.m_dst) && (m_expire == o.m_expire)); } - // /\name Fields + ///\name Fields // \{ Ptr GetPacket () const { @@ -144,21 +156,21 @@ public: } // \} private: - // / Data packet + /// Data packet Ptr m_packet; - // / Destination address + /// Destination address Ipv4Address m_dst; - // / Source address + /// Source address Ipv4Address m_source; - // / Nexthop address + /// Nexthop address Ipv4Address m_nextHop; - // / + /// uint16_t m_identification; uint16_t m_fragmentOffset; uint8_t m_segsLeft; - // / Expire time for queue entry + /// Expire time for queue entry Time m_expire; - // / The protocol number + /// The protocol number uint8_t m_protocol; }; @@ -170,31 +182,23 @@ private: class PassiveBuffer : public Object { public: - // / c-tor - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); - /** - * \brief Constructor. - */ + PassiveBuffer (); - /** - * \brief Destructor. - */ virtual ~PassiveBuffer (); - // / Push entry in queue, if there is no entry with the same packet and destination address in queue. + + /// Push entry in queue, if there is no entry with the same packet and destination address in queue. bool Enqueue (PassiveBuffEntry & entry); - // / Return first found (the earliest) entry for given destination + /// Return first found (the earliest) entry for given destination bool Dequeue (Ipv4Address dst, PassiveBuffEntry & entry); - // / Finds whether a packet with destination dst exists in the queue + /// Finds whether a packet with destination dst exists in the queue bool Find (Ipv4Address dst); - // / Check if all the entries in passive buffer entry is all equal or not + /// Check if all the entries in passive buffer entry is all equal or not bool AllEqual (PassiveBuffEntry & entry); - // / Number of entries + /// Number of entries uint32_t GetSize (); - // /\name Fields + ///\name Fields // \{ uint32_t GetMaxQueueLen () const { @@ -215,19 +219,19 @@ public: // \} private: - // / The send buffer to cache unsent packet + /// The send buffer to cache unsent packet std::vector m_passiveBuffer; - // / Remove all expired entries + /// Remove all expired entries void Purge (); - // / Notify that packet is dropped from queue by timeout + /// Notify that packet is dropped from queue by timeout void Drop (PassiveBuffEntry en, std::string reason); - // / Notify that packet is dropped from queue by timeout + /// Notify that packet is dropped from queue by timeout void DropLink (PassiveBuffEntry en, std::string reason); - // / The maximum number of packets that we allow a routing protocol to buffer. + /// The maximum number of packets that we allow a routing protocol to buffer. uint32_t m_maxLen; - // / The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. + /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_passiveBufferTimeout; - // / Check if the send buffer entry is the same or not + /// Check if the send buffer entry is the same or not static bool LinkEqual (PassiveBuffEntry en, const std::vector link) { return ((en.GetSource () == link[0]) && (en.GetNextHop () == link[1])); diff --git a/src/dsr/model/dsr-rcache.h b/src/dsr/model/dsr-rcache.h index 345d2c410..c6137b44f 100644 --- a/src/dsr/model/dsr-rcache.h +++ b/src/dsr/model/dsr-rcache.h @@ -155,14 +155,8 @@ private: class NodeStab { public: - /** - * \brief Constructor - */ -// NodeStab (); + NodeStab (Time nodeStab = Simulator::Now ()); - /** - * \brief Destructor - */ virtual ~NodeStab (); void SetNodeStability (Time nodeStab) @@ -182,18 +176,13 @@ class RouteCacheEntry public: typedef std::vector IP_VECTOR; ///< Define the vector to hold Ip address typedef std::vector::iterator Iterator; ///< Define the iterator - // / c-tor - /** - * \brief Constructor - */ + RouteCacheEntry (IP_VECTOR const & ip = IP_VECTOR (), Ipv4Address dst = Ipv4Address (), Time exp = Simulator::Now ()); - /** - * \brief Destructor - */ virtual ~RouteCacheEntry (); - // / Mark entry as "down" (i.e. disable it) + + /// Mark entry as "down" (i.e. disable it) void Invalidate (Time badLinkLifetime); - // /\name Fields + ///\name Fields // \{ void SetUnidirectional (bool u) { @@ -278,23 +267,14 @@ public: private: Timer m_ackTimer; ///< RREP_ACK timer - Ipv4Address m_dst; ///< The destination Ip address - IP_VECTOR m_path; ///< brief The IP address constructed route - Time m_expire; ///< Expire time for queue entry - Ipv4InterfaceAddress m_iface; ///< Output interface address - uint8_t m_reqCount; ///< Number of route requests - bool m_blackListState; ///< Indicate if this entry is in "blacklist" - Time m_blackListTimeout; ///< Time for which the node is put into the blacklist - Ptr m_ipv4Route; ///< The Ipv4 route - Ptr m_ipv4; ///< The Ipv4 layer 3 }; /** @@ -305,20 +285,12 @@ private: class RouteCache : public Object { public: - // / Default c-tor -/** - * \ingroup dsr - * \brief The Route Cache used by DSR - */ + static TypeId GetTypeId (); - /** - * \brief Constructor. - */ + RouteCache (); - /** - * \brief Destructor. - */ virtual ~RouteCache (); + /** * \brief Remove the aged route cache entries when the route cache is full */ @@ -327,7 +299,7 @@ public: * \brief Define the vector of route entries. */ typedef std::list routeVector; - // /\name Fields + ///\name Fields // \{ bool GetSubRoute () const { @@ -413,7 +385,6 @@ public: /** * \brief Update route cache entry if it has been recently used and successfully delivered the data packet * \param dst destination address of the route - * \param vec the route vector * \return true in success */ bool UpdateRouteEntry (Ipv4Address dst); @@ -425,8 +396,8 @@ public: bool AddRoute (RouteCacheEntry & rt); /** * \brief Lookup route cache entry with destination address dst - * \param dst destination address - * \param rt entry with destination address dst, if exists + * \param id destination address + * \param rt entry with destination address id, if exists * \return true on success */ bool LookupRoute (Ipv4Address id, RouteCacheEntry & rt); @@ -460,14 +431,14 @@ public: * \param node This node's ip address */ void DeleteAllRoutesIncludeLink (Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node); - // / Delete all entries from routing table + /// Delete all entries from routing table void Clear () { m_routeEntryVector.erase (m_routeEntryVector.begin (), m_routeEntryVector.end ()); } - // / Delete all outdated entries and invalidate valid entry if Lifetime is expired + /// Delete all outdated entries and invalidate valid entry if Lifetime is expired void Purge (); - // / Print route cache + /// Print route cache void Print (std::ostream &os); //------------------------------------------------------------------------------------------ @@ -484,7 +455,7 @@ public: /** * The following code handles link-layer acks */ - // / Neighbor description + /// Neighbor description struct Neighbor { Ipv4Address m_neighborAddress; @@ -549,7 +520,7 @@ public: { return m_txErrorCallback; } - // /\name Handle link failure callback + ///\name Handle link failure callback // \{ void SetCallback (Callback cb) { @@ -627,14 +598,14 @@ public: /** * \brief Dijsktra algorithm to get the best route from m_netGraph and update the m_bestRoutesTable_link * when current graph information has changed - * \param The type of the cache + * \param type The type of the cache */ void SetCacheType (std::string type); bool IsLinkCache (); bool AddRoute_Link (RouteCacheEntry::IP_VECTOR nodelist, Ipv4Address node); /** * \brief USE MAXWEIGHT TO REPRESENT MAX; USE BROADCAST ADDRESS TO REPRESENT NULL PRECEEDING ADDRESS - * \param The source address the routes based on + * \param source The source address the routes based on */ void RebuildBestRouteTable (Ipv4Address source); void PurgeLinkNode (); diff --git a/src/dsr/model/dsr-routing.h b/src/dsr/model/dsr-routing.h index 63423855a..50d3a0297 100644 --- a/src/dsr/model/dsr-routing.h +++ b/src/dsr/model/dsr-routing.h @@ -124,7 +124,7 @@ public: void SetNode (Ptr node); /** * \brief Set the route cache. - * \param the route cache to set + * \param r the route cache to set */ void SetRouteCache (Ptr r); /** @@ -134,7 +134,7 @@ public: Ptr GetRouteCache () const; /** * \brief Set the node. - * \param the request table to set + * \param r the request table to set */ void SetRequestTable (Ptr r); /** @@ -144,7 +144,7 @@ public: Ptr GetRequestTable () const; /** * \brief Set the node. - * \param the passive buffer to set + * \param r the passive buffer to set */ void SetPassiveBuffer (Ptr r); /** @@ -172,31 +172,37 @@ public: void ConnectCallbacks (); /** * \brief Get the netdevice from the context. + * \param context context * \return the netdevice we are looking for */ Ptr GetNetDeviceFromContext (std::string context); /** * \brief Get the elements from the tracing context. + * \param context context * \return the elements we are looking for */ std::vector GetElementsFromContext (std::string context); /** * \brief Get the node id from ip address. + * \param address IPv4 address * \return the node id */ uint16_t GetIDfromIP (Ipv4Address address); /** * \brief Get the ip address from id. + * \param id unique ID * \return the ip address for the id */ Ipv4Address GetIPfromID (uint16_t id); /** * \brief Get the Ip address from mac address. + * \param address Mac48Address * \return the ip address */ Ipv4Address GetIPfromMAC (Mac48Address address); /** * \brief Get the node with give ip address. + * \param ipv4Address IPv4 address * \return the node associated with the ip address */ Ptr GetNodeWithAddress (Ipv4Address ipv4Address); @@ -206,6 +212,8 @@ public: void PrintVector (std::vector& vec); /** * \brief Get the next hop of the route. + * \param ipv4Address + * \param vec Route * \return the next hop address of the route */ Ipv4Address SearchNextHop (Ipv4Address ipv4Address, std::vector& vec); @@ -230,13 +238,16 @@ public: Ipv4Address destination, uint8_t protocol); /** - * \brief Set the route to use for data packets + * \brief Set the route to use for data packets, + * used by the option headers when sending data/control packets + * \param nextHop next hop IPv4 address + * \param srcAddress IPv4 address of the source * \return the route - * \used by the option headers when sending data/control packets */ Ptr SetRoute (Ipv4Address nextHop, Ipv4Address srcAddress); /** * \brief Set the priority of the packet in network queue + * \param messageType Message type * \return the priority value */ uint32_t GetPriority (DsrMessageType messageType); @@ -378,28 +389,28 @@ public: uint8_t protocol); /** * \brief Send the error request packet - * \param the route error header - * \param the protocol number + * \param rerr the route error header + * \param protocol the protocol number */ void SendErrorRequest (DsrOptionRerrUnreachHeader &rerr, uint8_t protocol); /** * \brief Forward the route request if the node is not the destination - * \param the original packet + * \param packet the original packet * \param source address */ void SendRequest (Ptr packet, Ipv4Address source); /** * \brief Schedule the intermediate route request - * \param the original packet - * \param source The source address - * \param destination The destination address + * \param packet the original packet */ void ScheduleInterRequest (Ptr packet); /** * \brief Send the gratuitous reply * \param replyTo The destination address to send the reply to * \param replyFrom The source address sending the reply + * \param nodeList Route + * \param protocol the protocol number */ void SendGratuitousReply (Ipv4Address replyTo, Ipv4Address replyFrom, @@ -407,6 +418,11 @@ public: uint8_t protocol); /** * Send the route reply back to the request originator with the cumulated route + * + * \param packet the original packet + * \param source IPv4 address of the source (i.e. request originator) + * \param nextHop IPv4 address of the next hop + * \param route Route */ void SendReply (Ptr packet, Ipv4Address source, @@ -415,6 +431,11 @@ public: /** * this is a generating the initial route reply from the destination address, a random delay time * [0, m_broadcastJitter] is used before unicasting back the route reply packet + * + * \param packet the original packet + * \param source IPv4 address of the source (i.e. request originator) + * \param nextHop IPv4 address of the next hop + * \param route Route */ void ScheduleInitialReply (Ptr packet, Ipv4Address source, @@ -422,6 +443,11 @@ public: Ptr route); /** * Schedule the cached reply to a random start time to avoid possible route reply storm + * + * \param packet the original packet + * \param source IPv4 address of the source (i.e. request originator) + * \param destination IPv4 address of the destination + * \param route Route */ void ScheduleCachedReply (Ptr packet, Ipv4Address source, @@ -430,6 +456,13 @@ public: double hops); /** * Send network layer acknowledgment back to the earlier hop to notify the receipt of data packet + * + * \param ackId ACK ID + * \param destination IPv4 address of the immediate ACK receiver + * \param realSrc IPv4 address of the real source + * \param realDst IPv4 address of the real destination + * \param protocol the protocol number + * \param route Route */ void SendAck (uint16_t ackId, Ipv4Address destination, @@ -441,6 +474,7 @@ public: * \param p packet to forward up * \param header IPv4 Header information * \param incomingInterface the Ipv4Interface on which the packet arrived + * \return receive status * * Called from lower-level layers to send the packet up * in the stack. @@ -453,6 +487,7 @@ public: * \param p packet to forward up * \param header IPv6 Header information * \param incomingInterface the Ipv6Interface on which the packet arrived + * \return receive status * * Called from lower-level layers to send the packet up * in the stack. Not implemented (IPv6). @@ -470,9 +505,10 @@ public: * Called from Ipv4L3Protocol::Receive. * * \param packet the packet - * \param offset the offset of the extension to process + * \param ipv4Header IPv4 header of the packet * \param dst destination address of the packet received (i.e. us) * \param nextHeader the next header + * \param protocol the protocol number * \param isDropped if the packet must be dropped * \return the size processed */ @@ -496,10 +532,21 @@ public: void CancelRreqTimer (Ipv4Address dst, bool isRemove); /** * \brief Schedule the route request retry. - * \param dst The dst address of the route request + * \param packet the original packet + * \param address List of IPv4 addresses + * \param nonProp flag if RREQ is non-propagating + * \param requestId Unique request ID + * \param protocol the protocol number */ void ScheduleRreqRetry (Ptr packet, std::vector address, bool nonProp, uint32_t requestId, uint8_t protocol); - // / Handle route discovery timer + /** + * Handle route discovery timer + * + * \param packet the original packet + * \param address List of IPv4 addresses + * \param requestId Unique request ID + * \param protocol the protocol number + */ void RouteRequestTimerExpire (Ptr packet, std::vector address, uint32_t requestId, uint8_t protocol); /** @@ -548,6 +595,7 @@ private: * \param from The from address we received the packet * \param to The address this packet is destined for * \param packetType The dsr packet type, 0 is for control packet, 1 for data packet + * \return true if the packet was processed, false otherwise */ bool PromiscReceive (Ptr device, Ptr packet, uint16_t protocol, const Address &from, const Address &to, NetDevice::PacketType packetType); diff --git a/src/dsr/model/dsr-rreq-table.h b/src/dsr/model/dsr-rreq-table.h index 7e9ed2eca..701ff4db2 100644 --- a/src/dsr/model/dsr-rreq-table.h +++ b/src/dsr/model/dsr-rreq-table.h @@ -43,18 +43,27 @@ namespace ns3 { namespace dsr { +/** + * State of link + */ enum LinkStates { - PROBABLE = 0, // !< PROBABLE - QUESTIONABLE = 1, // !< QUESTIONABLE + PROBABLE = 0, //!< PROBABLE + QUESTIONABLE = 1, //!< QUESTIONABLE }; -// / BlackList description +/// BlackList description struct BlackList { - Ipv4Address m_neighborAddress; - Time m_expireTime; - LinkStates m_linkStates; + Ipv4Address m_neighborAddress; //!< IPv4 address of the black-listed neighbor + Time m_expireTime; //!< Expire time in the black list + LinkStates m_linkStates; //!< State of the link + /** + * Construct a BlackList with the given parameters + * + * \param ip IPv4 address of the neighbor + * \param t expire time for the black list entry + */ BlackList (Ipv4Address ip, Time t) : m_neighborAddress (ip), m_expireTime (t), @@ -67,8 +76,8 @@ struct BlackList */ struct RreqTableEntry { - uint32_t m_reqNo; - Time m_expire; + uint32_t m_reqNo; //!< Route request number + Time m_expire; //!< Expire time }; /** * The request entry for intermediate nodes to check if they have received this request or not @@ -77,14 +86,20 @@ struct RreqTableEntry class ReceivedRreqEntry { public: - // / c-tor + /** + * Construct a ReceivedRreqEntry with the given parameters + * + * \param d IPv4 address of the destination + * \param i identification + */ ReceivedRreqEntry (Ipv4Address d = Ipv4Address (), uint16_t i = 0) : m_destination (d), m_identification (i) { } /** - * \brief Compare send buffer entries + * \brief Compare send buffer entries (destination address and identification) + * \param o another ReceivedRreqEntry * \return true if equal */ bool operator== (ReceivedRreqEntry const & o) const @@ -92,46 +107,89 @@ public: return ((m_destination == o.m_destination) && (m_identification == o.m_identification) ); } - // /\name Fields - // \{ + + /** + * Return IPv4 address of the destination + * + * \return IPv4 address of the destination + */ Ipv4Address GetDestination () const { return m_destination; } + /** + * Set IPv4 address of the destination + * + * \param d IPv4 address of the destination + */ void SetDestination (Ipv4Address d) { m_destination = d; } + /** + * Return IPv4 address of the source + * + * \return IPv4 address of the source + */ Ipv4Address GetSource () const { return m_source; } + /** + * Set IPv4 address of the source + * + * \param s IPv4 address of the source + */ void SetSource (Ipv4Address s) { m_source = s; } + /** + * Return identification + * + * \return identification + */ uint16_t GetIdentification () const { return m_identification; } + /** + * Set identification + * + * \param i identification + */ void SetIdentification (uint16_t i) { m_identification = i; } + /** + * Set expire time for the RREQ entry. + * Note that the parameter is duration but + * the stored value is the absolute time. + * + * \param exp duration before expire + */ void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } + /** + * Return the remaining time before the RREQ entry expires. + * Note that we return the remaining time but the stored + * value is the absolute time. + * + * \return the remaining time before the RREQ entry expires + */ Time GetExpireTime () const { return m_expire - Simulator::Now (); } // \} private: - Ipv4Address m_destination; - Ipv4Address m_source; - uint16_t m_identification; - Time m_expire; + Ipv4Address m_destination; //!< IPv4 address of the destinaton + Ipv4Address m_source; //!< IPv4 address of the source + uint16_t m_identification; //!< Route request identification + Time m_expire; //!< Route request expire time }; /** @@ -141,81 +199,122 @@ private: class RreqTable : public Object { public: - // / c-tor - /** - * \brief Get the type identificator. - * \return type identificator - */ + static TypeId GetTypeId (); - /** - * \brief Constructor. - */ + RreqTable (); - /** - * \brief Destructor. - */ virtual ~RreqTable (); - // /\name Fields - // \{ + /** + * Set the initial discovert hop limit + * + * \param hl the initial discovert hop limit + */ void SetInitHopLimit (uint32_t hl) { m_initHopLimit = hl; } + /** + * Return the initial discovert hop limit + * + * \return the initial discovert hop limit + */ uint32_t GetInitHopLimit () const { return m_initHopLimit; } + /** + * Set the maximum number of request entries in + * the request table. + * + * \param rt the maximum number of request entries + */ void SetRreqTableSize (uint32_t rt) { m_requestTableSize = rt; } + /** + * Return the maximum number of request entries in + * the request table. + * + * \return the maximum number of request entries + */ uint32_t GetRreqTableSize () const { return m_requestTableSize; } + /** + * Set the maximum number of request source Ids in + * the request table + * + * \param id the maximum number of request source Ids + */ void SetRreqIdSize (uint32_t id) { m_requestIdSize = id; } + /** + * Return the maximum number of request source Ids in + * the request table + * + * \return the maximum number of request source Ids + */ uint32_t GetRreqIdSize () const { return m_requestIdSize; } + /** + * Set the maximum number of request Ids in + * the request table for a single destination. + * + * \param uid the maximum number of request Ids + */ void SetUniqueRreqIdSize (uint32_t uid) { m_maxRreqId = uid; } + /** + * Return the maximum number of request Ids in + * the request table for a single destination. + * + * \return the maximum number of request Ids + */ uint32_t GetUniqueRreqIdSize () const { return m_maxRreqId; } - // \} - // / Remove the least used entry + /// Remove the least used entry void RemoveLeastExpire (std::map & rreqDstMap); - // / Find the entry in the route request queue to see if already exists + /// Find the entry in the route request queue to see if already exists void FindAndUpdate (Ipv4Address dst); - // / Remove route request entry for dst + /// Remove route request entry for dst void RemoveRreqEntry (Ipv4Address dst); - // / Get the request count number for one destination address + /// Get the request count number for one destination address uint32_t GetRreqCnt (Ipv4Address dst); - //---------------------------------------------------------------------------------------------------------- + /** - * The following code generates new request id for each destination + * The following code generates new request id for each destination. + * Check for duplicate ids and save new entries if the id is not present in the table. + * + * \param dst IPv4 address of the destination + * \return id */ - // / Check for duplicate ids and save new entries if the id is not present in the table uint32_t CheckUniqueRreqId (Ipv4Address dst); - // / Get the request id size + /** + * Get the request id size + * + * \return the request id size + */ uint32_t GetRreqSize (); - // --------------------------------------------------------------------------------------------------------- + /** * set the unidirectional entry as QUESTIONABLE state */ void Invalidate (); /** * \brief Verify if entry is unidirectional or not(e.g. add this neighbor to "blacklist" for blacklistTimeout period) - * \param neighbor - neighbor address link to which assumed to be unidirectional + * \param neighbor neighbor address link to which assumed to be unidirectional * \return true on success */ BlackList* FindUnidirectional (Ipv4Address neighbor); @@ -226,50 +325,59 @@ public: * \return true on success */ bool MarkLinkAsUnidirectional (Ipv4Address neighbor, Time blacklistTimeout); - ///< Remove all expired black list entries + /** + * Remove all expired black list entries + */ void PurgeNeighbor (); - // ---------------------------------------------------------------------------------------------------------- + /** * Find the source request entry in the route request queue, return false if not found * \param src the source address we just received the source request * \param dst the destination address the request is targeted at * \param id the identification number for this request + * \return true if found, false otherwise */ bool FindSourceEntry (Ipv4Address src, Ipv4Address dst, uint16_t id); private: - // / The max request period among requests + /// The max request period among requests Time MaxRequestPeriod; - // / The original request period + /// The original request period Time RequestPeriod; - // / The non-propagaton request timeout + /// The non-propagaton request timeout Time NonpropRequestTimeout; - // / The source route entry expire time + /// The source route entry expire time Time m_rreqEntryExpire; - // / The initial hop limit + /// The initial hop limit uint32_t m_initHopLimit; - // / The request table size + /// The request table size uint32_t m_requestTableSize; - // / The request source id size + /// The request source id size uint32_t m_requestIdSize; - // / The unique request id for any destination + /// The unique request id for any destination uint32_t m_maxRreqId; - // / The state of the unidirectional link + /// The state of the unidirectional link LinkStates m_linkStates; - // / Map of entries + /// Map of entries std::list m_sourceRequests; - // / The id cache to ensure all the ids are unique, it is used when sending out route request + /// The id cache to ensure all the ids are unique, it is used when sending out route request std::map m_rreqIdCache; - // / The cache to save route request table entries indexed with destination address + /// The cache to save route request table entries indexed with destination address std::map m_rreqDstMap; - // / The cache to ensure all the route request from unique source + /// The cache to ensure all the route request from unique source std::map > m_sourceRreqMap; - // / The Black list + /// The Black list std::vector m_blackList; - // / Check if the entry is expired or not + /// Check if the entry is expired or not struct IsExpired { + /** + * Check if the entry is expired + * + * \param b BlackList entry + * \return true if expired, false otherwise + */ bool operator() (const struct BlackList & b) const { return (b.m_expireTime < Simulator::Now ()); diff --git a/src/dsr/model/dsr-rsendbuff.h b/src/dsr/model/dsr-rsendbuff.h index 83f3457af..79611aeed 100644 --- a/src/dsr/model/dsr-rsendbuff.h +++ b/src/dsr/model/dsr-rsendbuff.h @@ -45,7 +45,14 @@ namespace dsr { class SendBuffEntry { public: - // / c-tor + /** + * Construct SendBuffEntry with the given parameters. + * + * \param pa packet + * \param d destination address + * \param exp expiration time + * \param p protocol number + */ SendBuffEntry (Ptr pa = 0, Ipv4Address d = Ipv4Address (), Time exp = Simulator::Now (), uint8_t p = 0) : m_packet (pa), @@ -56,6 +63,7 @@ public: } /** * Compare send buffer entries + * \param o another SendBuffEntry * \return true if equal */ bool operator== (SendBuffEntry const & o) const @@ -98,13 +106,13 @@ public: } // \} private: - // / Data packet + /// Data packet Ptr m_packet; - // / Destination address + /// Destination address Ipv4Address m_dst; - // / Expire time for queue entry + /// Expire time for queue entry Time m_expire; - // / The protocol number + /// The protocol number uint8_t m_protocol; }; @@ -116,40 +124,93 @@ private: class SendBuffer { public: - // / Default c-tor + /** + * Default constructor + */ SendBuffer () { } - // / Push entry in queue, if there is no entry with the same packet and destination address in queue. + /** + * Push entry in queue, if there is no entry with + * the same packet and destination address in queue. + * + * \param entry SendBuffEntry to put in the queue + * \return true if successfully enqueued, + * false otherwise + */ bool Enqueue (SendBuffEntry & entry); - // / Return first found (the earliest) entry for given destination + /** + * Return first found (the earliest) entry for + * the given destination. + * + * \param dst IPv4 address of the destination + * \param entry pointer to entry to return + * \return true if successfully dequeued, + * false otherwise + */ bool Dequeue (Ipv4Address dst, SendBuffEntry & entry); - // / Remove all packets with destination IP address dst + /** + * Remove all packets with destination IP address dst + * + * \param dst IPv4 address of the destination + */ void DropPacketWithDst (Ipv4Address dst); - // / Finds whether a packet with destination dst exists in the queue + /** + * Check if a packet with destination dst exists in the queue + * + * \param dst IPv4 address of the destination + * \return true if found, false otherwise + */ bool Find (Ipv4Address dst); - // / Number of entries + /** + * Number of entries + * + * \return the number of entries in the queue + */ uint32_t GetSize (); - // /\name Fields - // \{ + /** + * Return the maximum queue length + * + * \return the maximum queue length + */ uint32_t GetMaxQueueLen () const { return m_maxLen; } + /** + * Set the maximum queue length + * + * \param len the maximum queue length + */ void SetMaxQueueLen (uint32_t len) { m_maxLen = len; } + /** + * Return the entry lifetime in the queue + * + * \return the entry lifetime in the queue + */ Time GetSendBufferTimeout () const { return m_sendBufferTimeout; } + /** + * Set the entry lifetime in the queue + * + * \param t the entry lifetime in the queue + */ void SetSendBufferTimeout (Time t) { m_sendBufferTimeout = t; } // \} + /** + * Return a pointer to the internal queue + * + * \return a pointer to the internal queue + */ std::vector & GetBuffer () { return m_sendBuffer; @@ -162,7 +223,15 @@ private: void Drop (SendBuffEntry en, std::string reason); ///< Notify that packet is dropped from queue by timeout uint32_t m_maxLen; ///< The maximum number of packets that we allow a routing protocol to buffer. Time m_sendBufferTimeout; ///< The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. - static bool IsEqual (SendBuffEntry en, const Ipv4Address dst) ///< Check if the send buffer entry is the same or not + /** + * Check if the send buffer entry is the same or not + * + * \param en SendBufferEntry + * \param dst IPv4 address to check + * \return true if the SendBufferEntry destination is the same, + * false otherwise + */ + static bool IsEqual (SendBuffEntry en, const Ipv4Address dst) { return (en.GetDestination () == dst); }