add new repoHEADmaster

1 files changed, 396 insertions, 0 deletions

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Router 1760/cmd_routerBGP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Router 1760/cmd_routerBGP.txt
new file mode 100644
index 0000000..0e786c8
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Router 1760/cmd_routerBGP.txt
@@ -0,0 +1,396 @@
+

+routerBGPC.addSC("address-family", "Enter Address Family command mode");

+	routerBGPC["address-family"].addSC("ipmcast", "Address family");

+	routerBGPC["address-family"].addSC("ipv4", "Address family");

+		routerBGPC["address-family"].ipv4.addSC("multicast", "Address Family modifier");

+		routerBGPC["address-family"].ipv4.addSC("unicast", "Address Family modifier");

+		routerBGPC["address-family"].ipv4.addSC("vrf", "Specify parameters for a VPN Routing/Forwarding instance");

+			routerBGPC["address-family"].ipv4.vrf.addSC("WORD", "VPN Routing/Forwarding instance name");

+	routerBGPC["address-family"].addSC("ipv6", "Address family");

+		routerBGPC["address-family"].ipv6.addSC("unicast", "Address Family modifier");

+	routerBGPC["address-family"].addSC("nsap", "Address family");

+		routerBGPC["address-family"].nsap.addSC("unicast", "Address Family Modifier");

+	routerBGPC["address-family"].addSC("vpnv4", "Address family");

+		routerBGPC["address-family"].vpnv4.addSC("unicast", "Address Family Modifier");

+routerBGPC.addSC("aggregate-address", "Configure BGP aggregate entries");

+	routerBGPC["aggregate-address"].addSC("A.B.C.D", "Aggregate address");

+		routerBGPC["aggregate-address"]["A.B.C.D"].addSC("A.B.C.D", "Aggregate mask");

+			routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("advertise-map", "Set condition to advertise attribute");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+			routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("as-set", "Generate AS set path information");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+			routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("attribute-map", "Set attributes of aggregate");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].addSC("WORD", "Route map for parameter control");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+			routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("route-map", "Set parameters of aggregate");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].addSC("WORD", "Route map for parameter control");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].WORD.addSC("as-set", "Generate AS set path information");

+			routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("summary-only", "Filter more specific routes from updates");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("advertise-map", "Set condition to advertise attribute");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("as-set", "Generate AS set path information");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("attribute-map", "Set attributes of aggregate");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].addSC("WORD", "Route map for parameter control");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+								routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("route-map", "Set parameters of aggregate");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].addSC("WORD", "Route map for parameter control");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].WORD.addSC("as-set", "Generate AS set path information");

+			routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("suppress-map", "Conditionally filter more specific routes from updates");

+				routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].addSC("WORD", "Route map for suppression");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("as-set", "Generate AS set path information");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("attribute-map", "Set attributes of aggregate");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].addSC("WORD", "Route map for parameter control");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");

+								routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");

+								routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+									routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("route-map", "Set parameters of aggregate");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].addSC("WORD", "Route map for parameter control");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].WORD.addSC("as-set", "Generate AS set path information");

+					routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("summary-only", "Filter more specific routes from updates");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("advertise-map", "Set condition to advertise attribute");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("as-set", "Generate AS set path information");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+								routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("attribute-map", "Set attributes of aggregate");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].addSC("WORD", "Route map for parameter control");

+								routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");

+									routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");

+								routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");

+									routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");

+						routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("route-map", "Set parameters of aggregate");

+							routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].addSC("WORD", "Route map for parameter control");

+								routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].WORD.addSC("as-set", "Generate AS set path information");

+routerBGPC.addSC("auto-summary", "Enable automatic network number summarization");

+routerBGPC.addSC("bgp", "BGP specific commands");

+	routerBGPC.bgp.addSC("always-compare-med", "Allow comparing MED from different neighbors");

+	routerBGPC.bgp.addSC("bestpath", "Change the default bestpath selection");

+		routerBGPC.bgp.bestpath.addSC("compare-routerid", "Compare router-id for identical EBGP paths");

+		routerBGPC.bgp.bestpath.addSC("med", "MED attribute");

+			routerBGPC.bgp.bestpath.med.addSC("confed", "Compare MED among confederation paths");

+			routerBGPC.bgp.bestpath.med.addSC("missing-as-worst", "Treat missing MED as the least preferred one");

+	routerBGPC.bgp.addSC("client-to-client", "Configure client to client route reflection");

+		routerBGPC.bgp["client-to-client"].addSC("reflection", "reflection of routes allowed");

+	routerBGPC.bgp.addSC("cluster-id", "Configure Route-Reflector Cluster-id");

+		routerBGPC.bgp["cluster-id"].addSC("<1-4294967295>", "Route-Reflector Cluster-id as 32 bit quantity");

+		routerBGPC.bgp["cluster-id"].addSC("A.B.C.D", "Route-Reflector Cluster-id in IP address format");

+	routerBGPC.bgp.addSC("confederation", "AS confederation parameters");

+		routerBGPC.bgp.confederation.addSC("identifier", "as number");

+			routerBGPC.bgp.confederation.identifier.addSC("<1-65535>", "Set routing domain confederation AS");

+		routerBGPC.bgp.confederation.addSC("peers", "Peer ASs in BGP confederation");

+			routerBGPC.bgp.confederation.peers.addSC("<1-65535>", "AS number");

+	routerBGPC.bgp.addSC("dampening", "Enable route-flap dampening");

+		routerBGPC.bgp.dampening.addSC("<1-45>", "Half-life time for the penalty");

+			routerBGPC.bgp.dampening["<1-45>"].addSC("<1-20000>", "Value to start reusing a route");

+				routerBGPC.bgp.dampening["<1-45>"]["<1-20000>"].addSC("<1-20000>", "Value to start suppressing a route");

+					routerBGPC.bgp.dampening["<1-45>"]["<1-20000>"]["<1-20000>"].addSC("<1-255>", "Maximum duration to suppress a stable route");

+		routerBGPC.bgp.dampening.addSC("route-map", "Route-map to specify criteria for dampening");

+			routerBGPC.bgp.dampening["route-map"].addSC("WORD", "route-map name");

+	routerBGPC.bgp.addSC("default", "Configure BGP defaults");

+		routerBGPC.bgp["default"].addSC("ipv4-unicast", "Activate ipv4-unicast for a peer by default");

+		routerBGPC.bgp["default"].addSC("local-preference", "local preference (higher=more preferred)");

+			routerBGPC.bgp["default"]["local-preference"].addSC("<0-4294967295>", "Configure default local preference value");

+		routerBGPC.bgp["default"].addSC("route-target", "Control behavior based on Route-Target attributes");

+			routerBGPC.bgp["default"]["route-target"].addSC("filter", "Control automatic VPN Route-Target filtering");

+	routerBGPC.bgp.addSC("deterministic-med", "Pick the best-MED path among paths advertised from the neighboring AS");

+	routerBGPC.bgp.addSC("dmzlink-bw", "Use DMZ Link Bandwidth as weight for BGP multipaths");

+	routerBGPC.bgp.addSC("fast-external-fallover", "Immediately reset session if a link to a directly connected external peer goes down");

+	routerBGPC.bgp.addSC("inject-map", "Routemap which specifies prefixes to inject");

+		routerBGPC.bgp["inject-map"].addSC("WORD", "route-map name");

+			routerBGPC.bgp["inject-map"].WORD.addSC("exist-map", "Routemap which specifies exist condition");

+	routerBGPC.bgp.addSC("log-neighbor-changes", "Log neighbor up/down and reset reason");

+	routerBGPC.bgp.addSC("redistribute-internal", "Allow redistribution of iBGP into IGPs (dangerous)");

+	routerBGPC.bgp.addSC("router-id", "Override configured router identifier");

+		routerBGPC.bgp["router-id"].addSC("A.B.C.D", "Manually configured router identifier");

+	routerBGPC.bgp.addSC("scan-time", "Configure background scanner interval");

+		routerBGPC.bgp["scan-time"].addSC("<5-60>", "Scanner interval (seconds)");

+routerBGPC.addSC("default", "Set a command to its defaults");

+	routerBGPC["default"].addSC("address-family", "Enter Address Family command mode");

+		routerBGPC["default"]["address-family"].addSC("ipmcast", "Address family");

+		routerBGPC["default"]["address-family"].addSC("ipv4", "Address family");

+		routerBGPC["default"]["address-family"].addSC("ipv6", "Address family");

+		routerBGPC["default"]["address-family"].addSC("nsap", "Address family");

+		routerBGPC["default"]["address-family"].addSC("vpnv4", "Address family");

+	routerBGPC["default"].addSC("aggregate-address", "Configure BGP aggregate entries");

+		routerBGPC["default"]["aggregate-address"].addSC("A.B.C.D", "Aggregate address");

+	routerBGPC["default"].addSC("auto-summary", "Enable automatic network number summarization");

+	routerBGPC["default"].addSC("bgp", "BGP specific commands");

+		routerBGPC["default"].bgp.addSC("always-compare-med", "Allow comparing MED from different neighbors");

+		routerBGPC["default"].bgp.addSC("bestpath", "Change the default bestpath selection");

+		routerBGPC["default"].bgp.addSC("client-to-client", "Configure client to client route reflection");

+		routerBGPC["default"].bgp.addSC("cluster-id", "Configure Route-Reflector Cluster-id");

+		routerBGPC["default"].bgp.addSC("confederation", "AS confederation parameters");

+		routerBGPC["default"].bgp.addSC("dampening", "Enable route-flap dampening");

+		routerBGPC["default"].bgp.addSC("default", "Configure BGP defaults");

+		routerBGPC["default"].bgp.addSC("deterministic-med", "Pick the best-MED path among paths advertised from the neighboring AS");

+		routerBGPC["default"].bgp.addSC("dmzlink-bw", "Use DMZ Link Bandwidth as weight for BGP multipaths");

+		routerBGPC["default"].bgp.addSC("fast-external-fallover", "Immediately reset session if a link to a directly connected external peer goes down");

+		routerBGPC["default"].bgp.addSC("inject-map", "Routemap which specifies prefixes to inject");

+		routerBGPC["default"].bgp.addSC("log-neighbor-changes", "Log neighbor up/down and reset reason");

+		routerBGPC["default"].bgp.addSC("redistribute-internal", "Allow redistribution of iBGP into IGPs (dangerous)");

+		routerBGPC["default"].bgp.addSC("router-id", "Override configured router identifier");

+		routerBGPC["default"].bgp.addSC("scan-time", "Configure background scanner interval");

+routerBGPC.addSC("default-information", "Control distribution of default information");

+	routerBGPC["default-information"].addSC("originate", "Distribute a default route");

+routerBGPC.addSC("default-metric", "Set metric of redistributed routes");

+	routerBGPC["default-metric"].addSC("<1-4294967295>", "Default metric");

+routerBGPC.addSC("distance", "Define an administrative distance");

+	routerBGPC.distance.addSC("<1-255>", "Administrative distance");

+		routerBGPC.distance["<1-255>"].addSC("A.B.C.D", "IP Source address");

+			routerBGPC.distance["<1-255>"]["A.B.C.D"].addSC("A.B.C.D", "IP address mask");

+				routerBGPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-99>", "IP Standard access list number");

+				routerBGPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1300-1999>", "IP Standard expanded access list number");

+	routerBGPC.distance.addSC("bgp", "BGP distance");

+		routerBGPC.distance.bgp.addSC("<1-255>", "Distance for routes external to the AS");

+			routerBGPC.distance.bgp["<1-255>"].addSC("<1-255>", "Distance for routes internal to the AS");

+				routerBGPC.distance.bgp["<1-255>"]["<1-255>"].addSC("<1-255>", "Distance for local routes");

+routerBGPC.addSC("distribute-list", "Filter networks in routing updates");

+routerBGPC.addSC("exit", "Exit from routing protocol configuration mode");

+routerBGPC.addSC("help", "Description of the interactive help system");

+routerBGPC.addSC("maximum-paths", "Forward packets over multiple paths");

+	routerBGPC["maximum-paths"].addSC("<1-6>", "Number of paths");

+	routerBGPC["maximum-paths"].addSC("ibgp", "iBGP-multipath");

+		routerBGPC["maximum-paths"].ibgp.addSC("<1-6>", "Number of paths");

+routerBGPC.addSC("neighbor", "Specify a neighbor router");

+	routerBGPC.neighbor.addSC("A.B.C.D", "Neighbor address");

+		routerBGPC.neighbor["A.B.C.D"].addSC("activate", "Enable the Address Family for this Neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("advertise-map", "specify route-map for conditional advertisement");

+			routerBGPC.neighbor["A.B.C.D"]["advertise-map"].addSC("WORD", "advertise route-map name");

+				routerBGPC.neighbor["A.B.C.D"]["advertise-map"].WORD.addSC("exist-map", "advertise prefix only if prefix is in the condition exists");

+					routerBGPC.neighbor["A.B.C.D"]["advertise-map"].WORD["exist-map"].addSC("WORD", "condition route-map name");

+				routerBGPC.neighbor["A.B.C.D"]["advertise-map"].WORD.addSC("non-exist-map", "advertise prefix only if prefix in the condition does not exist");

+					routerBGPC.neighbor["A.B.C.D"]["advertise-map"].WORD["non-exist-map"].addSC("WORD", "condition route-map name");

+		routerBGPC.neighbor["A.B.C.D"].addSC("advertisement-interval", "Minimum interval between sending BGP routing updates");

+			routerBGPC.neighbor["A.B.C.D"]["advertisement-interval"].addSC("<0-600>", "time in seconds");

+		routerBGPC.neighbor["A.B.C.D"].addSC("allowas-in", "Accept as-path with my AS present in it");

+			routerBGPC.neighbor["A.B.C.D"]["allowas-in"].addSC("<1-10>", "Number of occurances of AS number");

+		routerBGPC.neighbor["A.B.C.D"].addSC("capability", "Advertise capability to the peer");

+			routerBGPC.neighbor["A.B.C.D"].capability.addSC("orf", "Advertise ORF capability to the peer");

+				routerBGPC.neighbor["A.B.C.D"].capability.orf.addSC("prefix-list", "Advertise prefixlist ORF capability to this neighbor");

+					routerBGPC.neighbor["A.B.C.D"].capability.orf["prefix-list"].addSC("both", "Capability to SEND and RECEIVE the ORF to/from this neighbor");

+					routerBGPC.neighbor["A.B.C.D"].capability.orf["prefix-list"].addSC("receive", "Capability to RECEIVE the ORF from this neighbor");

+					routerBGPC.neighbor["A.B.C.D"].capability.orf["prefix-list"].addSC("send", "Capability to SEND the ORF to this neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("default-originate", "Originate default route to this neighbor");

+			routerBGPC.neighbor["A.B.C.D"]["default-originate"].addSC("route-map", "Route-map to specify criteria to originate default");

+				routerBGPC.neighbor["A.B.C.D"]["default-originate"]["route-map"].addSC("WORD", "route-map name");

+		routerBGPC.neighbor["A.B.C.D"].addSC("description", "Neighbor specific description");

+			routerBGPC.neighbor["A.B.C.D"].description.addSC("LINE", "Up to 80 characters describing this neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("distribute-list", "Filter updates to/from this neighbor");

+			routerBGPC.neighbor["A.B.C.D"]["distribute-list"].addSC("<1-199>", "IP access list number");

+				routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"].addSC("in", "Filter incoming updates");

+				routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"].addSC("out", "Filter outgoing updates");

+			routerBGPC.neighbor["A.B.C.D"]["distribute-list"].addSC("<1300-2699>", "IP access list number (expanded range)");

+				routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"].addSC("in", "Filter incoming updates");

+				routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"].addSC("out", "Filter outgoing updates");

+			routerBGPC.neighbor["A.B.C.D"]["distribute-list"].addSC("WORD", "IP Access-list name");

+				routerBGPC.neighbor["A.B.C.D"]["distribute-list"].WORD.addSC("in", "Filter incoming updates");

+				routerBGPC.neighbor["A.B.C.D"]["distribute-list"].WORD.addSC("out", "Filter outgoing updates");

+		routerBGPC.neighbor["A.B.C.D"].addSC("dmzlink-bw", "Propagate the DMZ link bandwidth");

+		routerBGPC.neighbor["A.B.C.D"].addSC("ebgp-multihop", "Allow EBGP neighbors not on directly connected networks");

+			routerBGPC.neighbor["A.B.C.D"]["ebgp-multihop"].addSC("<1-255>", "maximum hop count");

+		routerBGPC.neighbor["A.B.C.D"].addSC("filter-list", "Establish BGP filters");

+			routerBGPC.neighbor["A.B.C.D"]["filter-list"].addSC("<1-199>", "AS path access list");

+				routerBGPC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"].addSC("in", "Filter incoming routes");

+				routerBGPC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"].addSC("out", "Filter outgoing routes");

+		routerBGPC.neighbor["A.B.C.D"].addSC("local-as", "Specify a local-as number");

+			routerBGPC.neighbor["A.B.C.D"]["local-as"].addSC("<1-65535>", "AS number used as local AS");

+				routerBGPC.neighbor["A.B.C.D"]["local-as"]["<1-65535>"].addSC("no-prepend", "Do not prepend local-as to updates from ebgp peers");

+		routerBGPC.neighbor["A.B.C.D"].addSC("maximum-prefix", "Maximum number of prefix accept from this peer");

+			routerBGPC.neighbor["A.B.C.D"]["maximum-prefix"].addSC("<1-4294967295>", "maximum no. of prefix limit");

+				routerBGPC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"].addSC("<1-100>", "Threshold value (%) at which to generate a warning msg");

+				routerBGPC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"].addSC("warning-only", "Only give warning message when limit is exceeded");

+		routerBGPC.neighbor["A.B.C.D"].addSC("next-hop-self", "Disable the next hop calculation for this neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("next-hop-unchanged", "Propagate the iBGP paths's next hop unchanged for this neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("password", "Set a password");

+			routerBGPC.neighbor["A.B.C.D"].password.addSC("<0-7>", "Encryption type (0 to disable encryption, 7 for proprietary)");

+				routerBGPC.neighbor["A.B.C.D"].password["<0-7>"].addSC("LINE", "The password");

+		routerBGPC.neighbor["A.B.C.D"].addSC("peer-group", "Member of the peer-group");

+			routerBGPC.neighbor["A.B.C.D"]["peer-group"].addSC("WORD", "peer-group name");

+		routerBGPC.neighbor["A.B.C.D"].addSC("prefix-list", "Filter updates to/from this neighbor");

+			routerBGPC.neighbor["A.B.C.D"]["prefix-list"].addSC("WORD", "Name of a prefix list");

+				routerBGPC.neighbor["A.B.C.D"]["prefix-list"].WORD.addSC("in", "Filter incoming updates");

+				routerBGPC.neighbor["A.B.C.D"]["prefix-list"].WORD.addSC("out", "Filter outgoing updates");

+		routerBGPC.neighbor["A.B.C.D"].addSC("remote-as", "Specify a BGP neighbor");

+			routerBGPC.neighbor["A.B.C.D"]["remote-as"].addSC("<1-65535>", "AS of remote neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("remove-private-AS", "Remove private AS number from outbound updates");

+		routerBGPC.neighbor["A.B.C.D"].addSC("route-map", "Apply route map to neighbor");

+			routerBGPC.neighbor["A.B.C.D"]["route-map"].addSC("WORD", "Name of route map");

+				routerBGPC.neighbor["A.B.C.D"]["route-map"].WORD.addSC("in", "Apply map to incoming routes");

+				routerBGPC.neighbor["A.B.C.D"]["route-map"].WORD.addSC("out", "Apply map to outbound routes");

+		routerBGPC.neighbor["A.B.C.D"].addSC("route-reflector-client", "Configure a neighbor as Route Reflector client");

+		routerBGPC.neighbor["A.B.C.D"].addSC("send-community", "Send Community attribute to this neighbor");

+			routerBGPC.neighbor["A.B.C.D"]["send-community"].addSC("both", "Send Standard and Extended Community attributes");

+			routerBGPC.neighbor["A.B.C.D"]["send-community"].addSC("extended", "Send Extended Community attribute");

+			routerBGPC.neighbor["A.B.C.D"]["send-community"].addSC("standard", "Send Standard Community attribute");

+		routerBGPC.neighbor["A.B.C.D"].addSC("shutdown", "Administratively shut down this neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("soft-reconfiguration", "Per neighbor soft reconfiguration");

+			routerBGPC.neighbor["A.B.C.D"]["soft-reconfiguration"].addSC("inbound", "Allow inbound soft reconfiguration for this neighbor");

+		routerBGPC.neighbor["A.B.C.D"].addSC("timers", "BGP per neighbor timers");

+			routerBGPC.neighbor["A.B.C.D"].timers.addSC("<0-4294967295>", "Keepalive interval");

+				routerBGPC.neighbor["A.B.C.D"].timers["<0-4294967295>"].addSC("<0-4294967295>", "Holdtime");

+		routerBGPC.neighbor["A.B.C.D"].addSC("translate-update", "Translate Update to MBGP format");

+			routerBGPC.neighbor["A.B.C.D"]["translate-update"].addSC("nlri", "Specify type of nlri to translate to");

+				routerBGPC.neighbor["A.B.C.D"]["translate-update"].nlri.addSC("multicast", "Translate Update to multicast nlri");

+				routerBGPC.neighbor["A.B.C.D"]["translate-update"].nlri.addSC("unicast", "Process Update as unicast nlri");

+					routerBGPC.neighbor["A.B.C.D"]["translate-update"].nlri.unicast.addSC("multicast", "Translate Update to multicast nlri");

+		routerBGPC.neighbor["A.B.C.D"].addSC("unsuppress-map", "Route-map to selectively unsuppress suppressed routes");

+			routerBGPC.neighbor["A.B.C.D"]["unsuppress-map"].addSC("WORD", "Name of route map");

+		routerBGPC.neighbor["A.B.C.D"].addSC("update-source", "Source of routing updates");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Async", "Async interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Async.addSC("<1-5>", "Async interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("BVI", "Bridge-Group Virtual Interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].BVI.addSC("<1-255>", "BVI interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("CTunnel", "CTunnel interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].CTunnel.addSC("<0-2147483647>", "CTunnel interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Dialer", "Dialer interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Dialer.addSC("<0-255>", "Dialer interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("FastEthernet", "FastEthernet IEEE 802.3");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].FastEthernet.addSC("<0-0>", "FastEthernet interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Lex", "Lex interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Lex.addSC("<0-2147483647>", "Lex interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Loopback", "Loopback interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Loopback.addSC("<0-2147483647>", "Loopback interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("MFR", "Multilink Frame Relay bundle interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].MFR.addSC("<0-2147483647>", "MFR interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Multilink", "Multilink-group interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Multilink.addSC("<1-2147483647>", "Multilink interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Null", "Null interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Null.addSC("<0-0>", "Null interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Serial", "Serial");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Serial.addSC("<0-1>", "Serial interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Tunnel", "Tunnel interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Tunnel.addSC("<0-2147483647>", "Tunnel interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Vif", "PGM Multicast Host interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"].Vif.addSC("<1-1>", "Vif interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Virtual-Template", "Virtual Template interface");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"]["Virtual-Template"].addSC("<1-200>", "Virtual-Template interface number");

+			routerBGPC.neighbor["A.B.C.D"]["update-source"].addSC("Virtual-TokenRing", "Virtual TokenRing");

+				routerBGPC.neighbor["A.B.C.D"]["update-source"]["Virtual-TokenRing"].addSC("<0-2147483647>", "Virtual-TokenRing interface number");

+		routerBGPC.neighbor["A.B.C.D"].addSC("version", "Set the BGP version to match a neighbor");

+			routerBGPC.neighbor["A.B.C.D"].version.addSC("<4-4>", "Neighbor's BGP version");

+		routerBGPC.neighbor["A.B.C.D"].addSC("weight", "Set default weight for routes from this neighbor");

+			routerBGPC.neighbor["A.B.C.D"].weight.addSC("<0-65535>", "default weight");

+	routerBGPC.neighbor.addSC("WORD", "Neighbor tag");

+		routerBGPC.neighbor.WORD.addSC("activate", "Enable the Address Family for this Neighbor");

+		routerBGPC.neighbor.WORD.addSC("advertise-map", "specify route-map for conditional advertisement");

+			routerBGPC.neighbor.WORD["advertise-map"].addSC("WORD", "advertise route-map name");

+				routerBGPC.neighbor.WORD["advertise-map"].WORD.addSC("exist-map", "advertise prefix only if prefix is in the condition exists");

+					routerBGPC.neighbor.WORD["advertise-map"].WORD["exist-map"].addSC("WORD", "condition route-map name");

+				routerBGPC.neighbor.WORD["advertise-map"].WORD.addSC("non-exist-map", "advertise prefix only if prefix in the condition does not exist");

+					routerBGPC.neighbor.WORD["advertise-map"].WORD["non-exist-map"].addSC("WORD", "condition route-map name");

+		routerBGPC.neighbor.WORD.addSC("advertisement-interval", "Minimum interval between sending BGP routing updates");

+			routerBGPC.neighbor.WORD["advertisement-interval"].addSC("<0-600>", "time in seconds");

+		routerBGPC.neighbor.WORD.addSC("allowas-in", "Accept as-path with my AS present in it");

+			routerBGPC.neighbor.WORD["allowas-in"].addSC("<1-10>", "Number of occurances of AS number");

+		routerBGPC.neighbor.WORD.addSC("capability", "Advertise capability to the peer");

+			routerBGPC.neighbor.WORD.capability.addSC("orf", "Advertise ORF capability to the peer");

+				routerBGPC.neighbor.WORD.capability.orf.addSC("prefix-list", "Advertise prefixlist ORF capability to this neighbor");

+					routerBGPC.neighbor.WORD.capability.orf["prefix-list"].addSC("both", "Capability to SEND and RECEIVE the ORF to/from this neighbor");

+					routerBGPC.neighbor.WORD.capability.orf["prefix-list"].addSC("receive", "Capability to RECEIVE the ORF from this neighbor");

+					routerBGPC.neighbor.WORD.capability.orf["prefix-list"].addSC("send", "Capability to SEND the ORF to this neighbor");

+		routerBGPC.neighbor.WORD.addSC("default-originate", "Originate default route to this neighbor");

+			routerBGPC.neighbor.WORD["default-originate"].addSC("route-map", "Route-map to specify criteria to originate default");

+				routerBGPC.neighbor.WORD["default-originate"]["route-map"].addSC("WORD", "route-map name");

+		routerBGPC.neighbor.WORD.addSC("description", "Neighbor specific description");

+			routerBGPC.neighbor.WORD.description.addSC("LINE", "Up to 80 characters describing this neighbor");

+		routerBGPC.neighbor.WORD.addSC("distribute-list", "Filter updates to/from this neighbor");

+		routerBGPC.neighbor.WORD.addSC("dmzlink-bw", "Propagate the DMZ link bandwidth");

+		routerBGPC.neighbor.WORD.addSC("ebgp-multihop", "Allow EBGP neighbors not on directly connected networks");

+			routerBGPC.neighbor.WORD["ebgp-multihop"].addSC("<1-255>", "maximum hop count");

+		routerBGPC.neighbor.WORD.addSC("filter-list", "Establish BGP filters");

+			routerBGPC.neighbor.WORD["filter-list"].addSC("<1-199>", "AS path access list");

+				routerBGPC.neighbor.WORD["filter-list"]["<1-199>"].addSC("in", "Filter incoming routes");

+				routerBGPC.neighbor.WORD["filter-list"]["<1-199>"].addSC("out", "Filter outgoing routes");

+		routerBGPC.neighbor.WORD.addSC("local-as", "Specify a local-as number");

+			routerBGPC.neighbor.WORD["local-as"].addSC("<1-65535>", "AS number used as local AS");

+				routerBGPC.neighbor.WORD["local-as"]["<1-65535>"].addSC("no-prepend", "Do not prepend local-as to updates from ebgp peers");

+		routerBGPC.neighbor.WORD.addSC("maximum-prefix", "Maximum number of prefix accept from this peer");

+			routerBGPC.neighbor.WORD["maximum-prefix"].addSC("<1-4294967295>", "maximum no. of prefix limit");

+				routerBGPC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"].addSC("<1-100>", "Threshold value (%) at which to generate a warning msg");

+				routerBGPC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"].addSC("warning-only", "Only give warning message when limit is exceeded");

+		routerBGPC.neighbor.WORD.addSC("next-hop-self", "Disable the next hop calculation for this neighbor");

+		routerBGPC.neighbor.WORD.addSC("next-hop-unchanged", "Propagate the iBGP paths's next hop unchanged for this neighbor");

+		routerBGPC.neighbor.WORD.addSC("password", "Set a password");

+			routerBGPC.neighbor.WORD.password.addSC("<0-7>", "Encryption type (0 to disable encryption, 7 for proprietary)");

+				routerBGPC.neighbor.WORD.password["<0-7>"].addSC("LINE", "The password");

+		routerBGPC.neighbor.WORD.addSC("peer-group", "Configure peer-group");

+		routerBGPC.neighbor.WORD.addSC("prefix-list", "Filter updates to/from this neighbor");

+			routerBGPC.neighbor.WORD["prefix-list"].addSC("WORD", "Name of a prefix list");

+				routerBGPC.neighbor.WORD["prefix-list"].WORD.addSC("in", "Filter incoming updates");

+				routerBGPC.neighbor.WORD["prefix-list"].WORD.addSC("out", "Filter outgoing updates");

+		routerBGPC.neighbor.WORD.addSC("remote-as", "Specify a BGP neighbor");

+			routerBGPC.neighbor.WORD["remote-as"].addSC("<1-65535>", "AS of remote neighbor");

+		routerBGPC.neighbor.WORD.addSC("remove-private-AS", "Remove private AS number from outbound updates");

+		routerBGPC.neighbor.WORD.addSC("route-map", "Apply route map to neighbor");

+			routerBGPC.neighbor.WORD["route-map"].addSC("WORD", "Name of route map");

+				routerBGPC.neighbor.WORD["route-map"].WORD.addSC("in", "Apply map to incoming routes");

+				routerBGPC.neighbor.WORD["route-map"].WORD.addSC("out", "Apply map to outbound routes");

+		routerBGPC.neighbor.WORD.addSC("route-reflector-client", "Configure a neighbor as Route Reflector client");

+		routerBGPC.neighbor.WORD.addSC("send-community", "Send Community attribute to this neighbor");

+			routerBGPC.neighbor.WORD["send-community"].addSC("both", "Send Standard and Extended Community attributes");

+			routerBGPC.neighbor.WORD["send-community"].addSC("extended", "Send Extended Community attribute");

+			routerBGPC.neighbor.WORD["send-community"].addSC("standard", "Send Standard Community attribute");

+		routerBGPC.neighbor.WORD.addSC("shutdown", "Administratively shut down this neighbor");

+		routerBGPC.neighbor.WORD.addSC("soft-reconfiguration", "Per neighbor soft reconfiguration");

+			routerBGPC.neighbor.WORD["soft-reconfiguration"].addSC("inbound", "Allow inbound soft reconfiguration for this neighbor");

+		routerBGPC.neighbor.WORD.addSC("timers", "BGP per neighbor timers");

+			routerBGPC.neighbor.WORD.timers.addSC("<0-4294967295>", "Keepalive interval");

+				routerBGPC.neighbor.WORD.timers["<0-4294967295>"].addSC("<0-4294967295>", "Holdtime");

+		routerBGPC.neighbor.WORD.addSC("translate-update", "Translate Update to MBGP format");

+			routerBGPC.neighbor.WORD["translate-update"].addSC("nlri", "Specify type of nlri to translate to");

+				routerBGPC.neighbor.WORD["translate-update"].nlri.addSC("multicast", "Translate Update to multicast nlri");

+				routerBGPC.neighbor.WORD["translate-update"].nlri.addSC("unicast", "Process Update as unicast nlri");

+					routerBGPC.neighbor.WORD["translate-update"].nlri.unicast.addSC("multicast", "Translate Update to multicast nlri");

+		routerBGPC.neighbor.WORD.addSC("unsuppress-map", "Route-map to selectively unsuppress suppressed routes");

+			routerBGPC.neighbor.WORD["unsuppress-map"].addSC("WORD", "Name of route map");

+		routerBGPC.neighbor.WORD.addSC("update-source", "Source of routing updates");

+		routerBGPC.neighbor.WORD.addSC("version", "Set the BGP version to match a neighbor");

+			routerBGPC.neighbor.WORD.version.addSC("<4-4>", "Neighbor's BGP version");

+		routerBGPC.neighbor.WORD.addSC("weight", "Set default weight for routes from this neighbor");

+			routerBGPC.neighbor.WORD.weight.addSC("<0-65535>", "default weight");

+	routerBGPC.neighbor.addSC("X:X:X:X::X", "Neighbor IPv6 address");

+routerBGPC.addSC("network", "Specify a network to announce via BGP");

+	routerBGPC.network.addSC("A.B.C.D", "Network number");

+		routerBGPC.network["A.B.C.D"].addSC("backdoor", "Specify a BGP backdoor route");

+		routerBGPC.network["A.B.C.D"].addSC("mask", "Network mask");

+			routerBGPC.network["A.B.C.D"].mask.addSC("A.B.C.D", "Network mask");

+				routerBGPC.network["A.B.C.D"].mask["A.B.C.D"].addSC("backdoor", "Specify a BGP backdoor route");

+		routerBGPC.network["A.B.C.D"].addSC("route-map", "Route-map to modify the attributes");

+			routerBGPC.network["A.B.C.D"]["route-map"].addSC("WORD", "Name of the route map");

+				routerBGPC.network["A.B.C.D"]["route-map"].WORD.addSC("backdoor", "Specify a BGP backdoor route");

+routerBGPC.addSC("no", "Negate a command or set its defaults");

+	routerBGPC.no.addSC("address-family", "Enter Address Family command mode");

+		routerBGPC.no["address-family"].addSC("ipmcast", "Address family");

+		routerBGPC.no["address-family"].addSC("ipv4", "Address family");

+		routerBGPC.no["address-family"].addSC("ipv6", "Address family");

+		routerBGPC.no["address-family"].addSC("nsap", "Address family");

+		routerBGPC.no["address-family"].addSC("vpnv4", "Address family");

+	routerBGPC.no.addSC("aggregate-address", "Configure BGP aggregate entries");

+		routerBGPC.no["aggregate-address"].addSC("A.B.C.D", "Aggregate address");

+	routerBGPC.no.addSC("auto-summary", "Enable automatic network number summarization");

+	routerBGPC.no.addSC("bgp", "BGP specific commands");

+routerBGPC.addSC("redistribute", "Redistribute information from another routing protocol");

+routerBGPC.addSC("synchronization", "Perform IGP synchronization");

+routerBGPC.addSC("table-map", "Map external entry attributes into routing table");

+	routerBGPC["table-map"].addSC("WORD", "route-map name");

+routerBGPC.addSC("timers", "Adjust routing timers");

+	routerBGPC.timers.addSC("bgp", "BGP timers");

+		routerBGPC.timers.bgp.addSC("<0-4294967295>", "Keepalive interval");

+			routerBGPC.timers.bgp["<0-4294967295>"].addSC("<0-4294967295>", "Holdtime");