NED: Extended documentation of network nodes.

Author: levy

src/inet/node/aodv/AodvRouter.ned

@@ -11,20 +11,23 @@ import inet.node.inet.AdhocHost;
 import inet.routing.aodv.Aodv;
 
 //
-// It models a ~WirelessHost extended with ~Aodv submodule.
+// A mobile node with the Ad hoc On-Demand Distance Vector (AODV)
+// routing protocol. Extends AdhocHost by adding the AODV routing protocol module.
 //
-// AODV is an on-demand MANET routing protocol. Each node
-// works similar to a 'router': they manage their own routing
-// tables, send requests for routes, and consult the IP layer via
-// Netfilter hooks for data forwarding.
+// AODV is a reactive routing protocol designed for mobile ad hoc networks (MANETs).
+// Each node maintains its own routing table and discovers routes on-demand when
+// communication is needed, rather than proactively maintaining routes to all destinations.
 //
-// Scenarios where AODV routing is desired use this module as a
-// host module.
+// Key features:
+// - On-demand route discovery using Route Request (RREQ) and Route Reply (RREP) messages
+// - Route maintenance through Route Error (RERR) messages when links break
+// - Sequence numbers to ensure loop-free routes and route freshness
+// - Hop-by-hop routing where each node maintains only the next hop information
+// - Inherits wireless capabilities and mobility support from AdhocHost
 //
-// The AODV v.2 (known as Dymo) is also implemented: ~Dymo,
-// ~DymoRouter.
+// The AODV v.2 (known as Dymo) is also implemented in INET as ~Dymo and ~DymoRouter.
 //
-// @see ~Aodv, ~Dymo, ~DymoRouter.
+// @see ~AdhocHost, ~DymoRouter, ~ManetRouter
 //
 module AodvRouter extends AdhocHost
 {

src/inet/node/base/ApplicationLayerNodeBase.ned

@@ -10,6 +10,18 @@ package inet.node.base;
 import inet.applications.contract.IApp;
 import inet.common.MessageDispatcher;
 
+//
+// An extension of the transport layer node base that adds support for applications.
+// Provides the highest level of abstraction for network nodes, completing the full
+// network stack from physical to application layer.
+//
+// This module adds an application layer with configurable application modules and
+// a message dispatcher that connects applications to the transport protocols.
+// It serves as the foundation for end-user devices like hosts and specialized nodes
+// that need application functionality.
+//
+// @see ~TransportLayerNodeBase, ~NetworkLayerNodeBase, ~StandardHost
+//
 module ApplicationLayerNodeBase extends TransportLayerNodeBase
 {
     parameters:

src/inet/node/base/LinkLayerNodeBase.ned

@@ -23,6 +23,16 @@ import inet.networklayer.common.InterfaceTable;
 import inet.node.contract.IEthernetNetworkNode;
 import inet.protocolelement.contract.IProtocolLayer;
 
+//
+// An extension of the basic node infrastructure with link layer
+// functionality. Provides support for various network interfaces and link layer
+// protocols, forming the foundation for network connectivity.
+//
+// This module adds an interface table and multiple types of network interfaces,
+// including Ethernet, PPP, wireless, loopback, tunnel, and virtual interfaces.
+// It also includes support for link layer protocols such as LLC, bridging,
+// and various Ethernet encapsulation methods.
+//
 module LinkLayerNodeBase extends NodeBase like IEthernetNetworkNode
 {
     parameters:

src/inet/node/base/NetworkLayerNodeBase.ned

@@ -10,6 +10,13 @@ package inet.node.base;
 import inet.common.MessageDispatcher;
 import inet.networklayer.contract.INetworkLayer;
 
+//
+// An extension of the link layer node base with network layer functionality.
+// Provides support for multiple network protocols, including IPv4 and IPv6.
+//
+// This module adds network layer capabilities to the node architecture, enabling
+// end-to-end connectivity across different networks.
+//
 module NetworkLayerNodeBase extends LinkLayerNodeBase
 {
     parameters:

src/inet/node/base/NodeBase.ned

@@ -18,10 +18,19 @@ import inet.power.contract.IEnergyManagement;
 import inet.power.contract.IEnergyStorage;
 
 //
-// This module contains the most basic infrastructure for network nodes that are
-// not strictly communication protocol-related.
+// The fundamental infrastructure for all network nodes focusing on non-communication
+// aspects of network nodes.
 //
-// See derived modules: ~StandardHost, ~WirelessHost, ~AdhocHost, ~Router, etc.
+// It provides among others:
+// - Node lifecycle management through NodeStatus
+// - Optional local clock for modeling clock skew
+// - Optional modules for with energy storage, management, and generation
+// - Support for node mobility
+//
+// NodeBase is not intended to be used directly in simulations but rather serves
+// as a base module for more specialized node types that add communication capabilities.
+//
+// @see ~StandardHost, ~WirelessHost, ~AdhocHost, ~Router
 //
 module NodeBase like INetworkNode
 {

src/inet/node/base/TransportLayerNodeBase.ned

@@ -12,6 +12,16 @@ import inet.transportlayer.contract.ISctp;
 import inet.transportlayer.contract.ITcp;
 import inet.transportlayer.contract.IUdp;
 
+//
+// An extension of the network layer node base with transport layer protocols.
+// Provides support for UDP, TCP, and SCTP, enabling end-to-end communication
+// services for applications.
+//
+// This module adds transport layer capabilities to the node architecture, bridging
+// the gap between applications and the network layer. It handles connection management,
+// reliability, flow control, and congestion control depending on the transport
+// protocol used.
+//
 module TransportLayerNodeBase extends NetworkLayerNodeBase
 {
     parameters:

src/inet/node/bgp/BgpRouter.ned

@@ -9,12 +9,24 @@ package inet.node.bgp;
 import inet.node.inet.Router;
 
 //
-// IP router with BGPv4 and OSPFv4 support.
+// A router that supports Border Gateway Protocol version 4 (BGPv4) along with Open Shortest
+// Path First version 4 (OSPFv4). It extends the standard Router module with BGP and OSPF
+// functionality enabled.
+//
+// BGP is the core routing protocol of the Internet that maintains paths to other autonomous
+// systems. It makes routing decisions based on network policies, rule-sets, and path attributes
+// rather than purely technical metrics. BGP is designed to exchange routing and reachability
+// information among autonomous systems on the Internet.
+//
+// The combination of BGP for external routing and OSPF for internal routing is a common
+// configuration in real-world networks, particularly for Internet Service Providers and
+// large enterprise networks.
+//
+// @see ~OspfRouter
 //
 module BgpRouter extends Router
 {
     parameters:
         hasBgp = true;
         hasOspf = true;
 }
-

src/inet/node/contract/IEthernetNetworkNode.ned

@@ -8,7 +8,15 @@
 package inet.node.contract;
 
 //
-// This is the module interface for all Ethernet node types in a network.
+// Interface for all network nodes that have Ethernet connectivity. Extends the base
+// INetworkNode interface by adding Ethernet-specific gates and parameters.
+//
+// This interface is implemented by various node types that participate in
+// Ethernet networks, such as hosts, switches, and routers with Ethernet interfaces.
+// It ensures that all Ethernet-capable nodes have the necessary gates to connect
+// to Ethernet networks.
+//
+// @see ~EthernetHost, ~EthernetSwitch, ~StandardHost, ~Router
 //
 moduleinterface IEthernetNetworkNode extends INetworkNode
 {

src/inet/node/contract/INetworkNode.ned

@@ -8,7 +8,13 @@
 package inet.node.contract;
 
 //
-// Contains the common interface for all node types in a network.
+// INetworkNode defines the common interface for all network node types in INET.
+// It serves as the base interface that all node modules must implement to be
+// recognized and treated as network nodes within the simulation.
+//
+// This interface provides no specific functionality itself but establishes
+// the common ground for different node types such as hosts, routers, switches,
+// and access points.
 //
 moduleinterface INetworkNode
 {

src/inet/node/dsdv/DsdvRouter.ned

@@ -11,7 +11,14 @@ import inet.node.inet.AdhocHost;
 import inet.routing.dsdv.Dsdv;
 
 //
-// A DSDV router.
+// A mobile node with the Destination-Sequenced Distance Vector
+// (DSDV) routing protocol. Extends AdhocHost by adding the DSDV routing protocol module.
+//
+// DSDV is a proactive, table-driven routing protocol designed for mobile ad hoc networks.
+// Each node maintains a routing table with entries for all possible destinations in the
+// network, along with the next hop and distance (number of hops) to reach them.
+//
+// @see ~AodvRouter
 //
 module DsdvRouter extends AdhocHost
 {