Compound Module OverlayRouter

File: Underlay/IPv4Underlay/OverlayRouter.ned

(no description)

namTrace: NAMTraceWriter notificationBoard: NotificationBoard interfaceTable: InterfaceTable routingTable: RoutingTable tier3: tier3Type like Tier tier2: tier2Type like Tier tier1: tier1Type like Tier overlay: overlayType like Overlay udp: UDP networkLayer: NetworkLayer ppp: PPPInterface

Usage diagram:

The following diagram shows usage relationships between modules, networks and channels. Unresolved module (and channel) types are missing from the diagram. Click here to see the full picture.

Contains the following modules:

If a module type shows up more than once, that means it has been defined in more than one NED file.

Overlay (no description)
Tier

A template for Tier1-3 modules

NAMTraceWriter (unknown -- not in documented files)
NotificationBoard (unknown -- not in documented files)
InterfaceTable (unknown -- not in documented files)
RoutingTable (unknown -- not in documented files)
UDP (unknown -- not in documented files)
NetworkLayer (unknown -- not in documented files)
PPPInterface (unknown -- not in documented files)

Used in compound modules:

If a module type shows up more than once, that means it has been defined in more than one NED file.

IPv4Underlay

The IPv4Underlay ned-file

See also: IPv4UnderlayConfigurator

Parameters:

Name Type Description
overlayType string
tier1Type string

the application on top off the overly used in the simulation

tier2Type string
tier3Type string
numTiers numeric const

number of tiers

IPForward bool
routingFile string

Gates:

Name Direction Description
in [ ] input
ethIn [ ] input
overlayNeighborArrowIn [ ] input
out [ ] output
ethOut [ ] output
overlayNeighborArrowOut [ ] output

Unassigned submodule parameters:

Name Type Description

Source code:

module OverlayRouter
    parameters:
        overlayType: string,
        tier1Type: string, // the application on top off the overly used in the simulation
        tier2Type: string,
        tier3Type: string,
        numTiers: numeric const, // number of tiers
        IPForward: bool,
        routingFile: string;

    gates:
        in: in[];
        in: ethIn[];
        in: overlayNeighborArrowIn[];

        out: out[];
        out: ethOut[];
        out: overlayNeighborArrowOut[];

    submodules:
        namTrace: NAMTraceWriter;
            parameters:
                namid = -1; // auto
            display: "p=82,420;i=block/sink";
        notificationBoard: NotificationBoard;
            display: "p=84,208;i=block/control";
        interfaceTable: InterfaceTable;
            display: "p=84,278;i=block/table";
        routingTable: RoutingTable;
            parameters:
                IPForward = IPForward,
                routerId = "",
                routingFile = routingFile;
            display: "p=84,348;i=block/table";
        tier3: tier3Type like Tier;
            display: "p=48,64;i=block/segm";
        tier2: tier2Type like Tier;
            display: "p=139,96;i=block/segm";
        tier1: tier1Type like Tier;
            display: "p=218,130;i=block/segm";
        overlay: overlayType like Overlay;
            display: "p=282,184;i=block/network2";
        udp: UDP;
            display: "p=282,262;i=block/transport";
        networkLayer: NetworkLayer;
            parameters:
                proxyARP = false;
            gatesizes:
                ifIn[sizeof(out)+sizeof(ethOut)],
                ifOut[sizeof(out)+sizeof(ethOut)];
            display: "p=282,340;i=block/fork;q=queue";
        ppp: PPPInterface[sizeof(out)];
            display: "p=282,422,row,90;q=txQueue;i=block/ifcard";
    connections nocheck:
        tier1.to_lowerTier --> overlay.from_app if numTiers > 0;
        tier1.from_lowerTier <-- overlay.to_app if numTiers > 0;
        tier1.to_udp --> udp.from_app++ if numTiers > 0;
        udp.to_app++ --> tier1.from_udp if numTiers > 0;

        tier2.to_lowerTier --> tier1.from_upperTier if numTiers > 1;
        tier2.from_lowerTier <-- tier1.to_upperTier if numTiers > 1;
        tier2.to_udp --> udp.from_app++ if numTiers > 1;
        udp.to_app++ --> tier2.from_udp if numTiers > 1;

        tier3.to_lowerTier --> tier2.from_upperTier if numTiers > 2;
        tier3.from_lowerTier <-- tier2.to_upperTier if numTiers > 2;
        tier3.to_udp --> udp.from_app++ if numTiers > 2;
        udp.to_app++ --> tier3.from_udp if numTiers > 2;

        overlay.to_udp --> udp.from_app++;
        overlay.from_udp <-- udp.to_app++;

        udp.to_ip --> networkLayer.UDPIn;
        udp.from_ip <-- networkLayer.UDPOut;

        // connections to network outside
        for i=0..sizeof(out)-1 do
            in[i] --> ppp[i].physIn;
            out[i] <-- ppp[i].physOut;
            ppp[i].netwOut --> networkLayer.ifIn[i];
            ppp[i].netwIn <-- networkLayer.ifOut[i];
        endfor;

    display: "b=360,476";
endmodule