module hc2vpp-ietf-routing { namespace "urn:ietf:params:xml:ns:yang:ietf-routing"; prefix "rt"; import ietf-yang-types { prefix "yang"; } import ietf-interfaces { prefix "if"; } organization "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; contact "WG Web: WG List: WG Chair: Thomas Nadeau WG Chair: Juergen Schoenwaelder Editor: Ladislav Lhotka "; description "This YANG module defines essential components for the management of a routing subsystem. Copyright (c) 2014 IETF Trust and the persons identified as authors of the code. All rights reserved. Redistribution and use in source and binary forms, with or without modification, is permitted pursuant to, and subject to the license terms contained in, the Simplified BSD License set forth in Section 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info). This version of this YANG module is part of RFC XXXX; see the RFC itself for full legal notices."; revision 2014-05-24 { description "Initial revision."; reference "RFC XXXX: A YANG Data Model for Routing Management"; } /* Features */ feature multiple-ribs { description "This feature indicates that the device supports multiple RIBS per address family, and the framework for passing routes between RIBs. Devices that do not support this feature MUST provide exactly one system-controlled RIB per supported address family. These RIBs then appear as entries of the list /routing-state/ribs/rib."; } feature multipath-routes { description "This feature indicates that the device supports multipath routes that have a list of next-hops."; } /* Identities */ identity address-family { description "Base identity from which identities describing address families are derived."; } identity ipv4 { base address-family; description "This identity represents IPv4 address family."; } identity ipv6 { base address-family; description "This identity represents IPv6 address family."; } identity routing-instance-type { description "Base identity from which identities describing routing instance types are derived. It is primarily intended for discriminating among different types of logical routers or router virtualization."; } identity standard-routing-instance { base routing-instance-type; description "This identity represents a default routing instance."; } identity routing-protocol { description "Base identity from which routing protocol identities are derived."; } identity direct { base routing-protocol; description "Routing pseudo-protocol which provides routes to directly connected networks."; } identity static { base routing-protocol; description "Static routing pseudo-protocol."; } identity route-filter { description "Base identity from which all route filters are derived."; } identity deny-all-route-filter { base route-filter; description "Route filter that blocks all routes."; } identity allow-all-route-filter { base route-filter; description "Route filter that permits all routes."; } /* Type Definitions */ typedef routing-instance-ref { type leafref { path "/rt:routing/rt:routing-instance/rt:name"; } description "This type is used for leafs that reference a routing instance configuration."; } typedef routing-instance-state-ref { type leafref { path "/rt:routing-state/rt:routing-instance/rt:name"; } description "This type is used for leafs that reference state data of a routing instance."; } typedef rib-ref { type leafref { path "/rt:routing/rt:ribs/rt:rib/rt:name"; } description "This type is used for leafs that reference a RIB configuration."; } typedef rib-state-ref { type leafref { path "/rt:routing-state/rt:ribs/rt:rib/rt:name"; } description "This type is used for leafs that reference a RIB in state data."; } typedef route-filter-ref { type leafref { path "/rt:routing/rt:route-filters/rt:route-filter/rt:name"; } description "This type is used for leafs that reference a route filter configuration."; } typedef route-filter-state-ref { type leafref { path "/rt:routing-state/rt:route-filters/rt:route-filter/" + "rt:name"; } description "This type is used for leafs that reference a route filter in state data."; } /* Groupings */ grouping address-family-grouping { description "This grouping provides a leaf identifying an address family."; leaf address-family { type identityref { base address-family; } mandatory "true"; description "Address family."; } } grouping state-entry-id { description "This grouping defines a unique identifier for entries in several operational state lists."; leaf id { type uint64; description "Unique numerical identifier of a list entry in operational state. It may be used by protocols or tools that inspect and/or manipulate operational state data and prefer fixed-size integers as list entry handles. These identifiers are always ephemeral, i.e., they may change after a reboot."; } } grouping router-id { description "This grouping provides the definition of router ID."; leaf router-id { type yang:dotted-quad; description "Router ID - 32-bit number in the form of a dotted quad. Some protocols use this parameter for identifying a router to its neighbors."; } } grouping outgoing-interface { description "This grouping defines the outgoing interface for use in next-hops."; leaf outgoing-interface { type leafref { path "/rt:routing-state/rt:routing-instance/rt:interfaces/" + "rt:interface/rt:name"; } description "Name of the outgoing interface."; } } // WARNING - renamed due to yang sources generation problem(having same name for grouping and it's leaf ends up in error against Java Language Specification) grouping special-next-hop-grouping { description "This grouping provides the leaf for specifying special next-hop options."; leaf special-next-hop { type enumeration { enum blackhole { description "Silently discard the packet."; } enum unreachable { description "Discard the packet and notify the sender with an error message indicating that the destination host is unreachable."; } enum prohibit { description "Discard the packet and notify the sender with an error message indicating that the communication is administratively prohibited."; } enum receive { description "The packet will be received by the local network device."; } } description "Special next-hop options."; } } grouping next-hop-classifiers { description "This grouping provides two next-hop classifiers."; leaf priority { type enumeration { enum primary { value "1"; description "Primary next-hop."; } enum backup { value "2"; description "Backup next-hop."; } } description "Simple priority for distinguishing between primary and backup next-hops. Backup next-hops are used if and only if no primary next-hops are reachable."; } leaf weight { type uint8; must ". = 0 or not(../../next-hop/weight = 0)" { error-message "Illegal combination of zero and non-zero " + "next-hop weights."; description "Next-hop weights must be either all zero (equal load-balancing) or all non-zero."; } description "This parameter specifies the weight of the next-hop for load balancing. The number specifies the relative fraction of the traffic that will use the corresponding next-hop. A value of 0 represents equal load-balancing. If both primary and backup next-hops are present, then the weights for each priority level are used separately."; } } grouping next-hop-content { description "Generic parameters of next-hops in routes."; choice next-hop-options { mandatory "true"; description "Options for expressing the next-hop in routes."; case special-next-hop { uses special-next-hop-grouping; } case simple-next-hop { uses outgoing-interface; } case next-hop-list { if-feature multipath-routes; container next-hop-list { description "Container for multiple next-hops."; list next-hop { key "id"; description "An entry of a next-hop list."; uses state-entry-id; uses outgoing-interface; uses next-hop-classifiers; } } } } } grouping route-metadata { description "Route metadata."; leaf source-protocol { type identityref { base routing-protocol; } mandatory "true"; description "Type of the routing protocol from which the route originated."; } leaf last-updated { type yang:date-and-time; description "Time stamp of the last modification of the route. If the route was never modified, it is the time when the route was inserted into the RIB."; } } /* Operational state data */ container routing-state { config "false"; description "Operational state of the routing subsystem."; list routing-instance { key "name"; unique "id"; description "Each list entry is a container for operational state data of a routing instance. An implementation MAY create one or more system-controlled instances, other user-controlled instances MAY be created by configuration."; leaf name { type string; description "The name of the routing instance. For system-controlled instances the name is persistent, i.e., it SHOULD NOT change across reboots."; } uses state-entry-id { refine "id" { mandatory "true"; } } leaf type { type identityref { base routing-instance-type; } description "The routing instance type, primarily intended for discriminating among different types of logical routers, route virtualization, master-slave arrangements etc., while keeping all routing instances in the same flat list."; } uses router-id { description "Global router ID. An implementation may choose a value if none is configured. Routing protocols that use router ID MAY override this global parameter."; } container default-ribs { description "Default RIBs used by the routing instance."; list default-rib { key "address-family"; description "Each list entry specifies the default RIB for one address family. The default RIB is operationally connected to all routing protocols for which a connected RIB has not been explicitly configured. The 'direct' pseudo-protocol is always connected to the default RIBs."; uses address-family-grouping; leaf rib-name { type rib-state-ref; mandatory "true"; description "Name of an existing RIB to be used as the default RIB for the given routing instance and address family."; } } } container interfaces { description "Network layer interfaces belonging to the routing instance."; list interface { key "name"; description "List of network layer interfaces assigned to the routing instance."; leaf name { type if:interface-state-ref; description "A reference to the name of a configured network layer interface."; } } } container routing-protocols { description "Container for the list of routing protocol instances."; list routing-protocol { key "name"; description "Operational state of a routing protocol instance. An implementation MUST provide exactly one system-controlled instance of the type 'direct'. Other instances MAY be created by configuration."; leaf name { type string; description "The name of the routing protocol instance. For system-controlled instances this name is persistent, i.e., it SHOULD NOT change across reboots."; } leaf type { type identityref { base routing-protocol; } mandatory "true"; description "Type of the routing protocol."; } container connected-ribs { description "Container for connected RIBs."; list connected-rib { key "rib-name"; description "List of RIBs to which the routing protocol instance is connected (at most one RIB per address family)."; leaf rib-name { type rib-state-ref; description "Name of an existing RIB."; } leaf import-filter { type route-filter-state-ref; description "Reference to a route filter that is used for filtering routes passed from this routing protocol instance to the RIB specified by the 'rib-name' sibling node. If this leaf is not present, the behavior is protocol-specific, but typically it means that all routes are accepted."; } leaf export-filter { type route-filter-state-ref; description "Reference to a route filter that is used for filtering routes passed from the RIB specified by the 'rib-name' sibling node to this routing protocol instance. If this leaf is not present, the behavior is protocol-specific - typically it means that all routes are accepted. The 'direct' and 'static' pseudo-protocols accept no routes from any RIB."; } } } //NOTE -added to allow operational state for static-routes container static-routes { when "../type='rt:static'" { description "This container is only valid for the 'static' routing protocol."; } description "Configuration of the 'static' pseudo-protocol. Address family specific modules augment this node with their lists of routes."; } } } } container ribs { description "Container for RIBs."; list rib { key "name"; unique "id"; description "Each entry represents a RIB identified by the 'name' key. All routes in a RIB MUST belong to the same address family. The server MUST provide a system-controlled default RIB for each address family, and MAY provide other system-controlled RIBs. Additional RIBs MAY be created in the configuration."; leaf name { type string; description "The name of the RIB."; } uses state-entry-id { refine "id" { mandatory "true"; } } uses address-family-grouping; container routes { description "Current contents of the RIB."; list route { key "id"; description "A RIB route entry. This data node MUST be augmented with information specific for routes of each address family."; uses state-entry-id; uses next-hop-content; uses route-metadata; } } container recipient-ribs { if-feature multiple-ribs; description "Container for recipient RIBs."; list recipient-rib { key "rib-name"; description "List of RIBs that receive routes from this RIB."; leaf rib-name { type rib-state-ref; description "The name of the recipient RIB."; } leaf filter { type route-filter-state-ref; description "A route filter which is applied to the routes passed to the recipient RIB."; } } } } } container route-filters { description "Container for route filters."; list route-filter { key "name"; description "Route filters are used for filtering and/or manipulating routes that are passed between a routing protocol and a RIB and vice versa, or between two RIBs. It is expected that other modules augment this list with contents specific for a particular route filter type."; leaf name { type string; description "The name of the route filter."; } leaf type { type identityref { base route-filter; } mandatory "true"; description "Type of the route-filter - an identity derived from the 'route-filter' base identity."; } } } } /* Configuration Data */ container routing { description "Configuration parameters for the routing subsystem."; list routing-instance { key "name"; description "Configuration of a routing instance."; leaf name { type string; description "The name of the routing instance. For system-controlled entries, the value of this leaf must be the same as the name of the corresponding entry in state data. For user-controlled entries, an arbitrary name can be used."; } leaf type { type identityref { base routing-instance-type; } default "rt:standard-routing-instance"; description "The type of the routing instance."; } leaf enabled { type boolean; default "true"; description "Enable/disable the routing instance. If this parameter is false, the parent routing instance is disabled and does not appear in operational state data, despite any other configuration that might be present."; } uses router-id { description "Configuration of the global router ID."; } leaf description { type string; description "Textual description of the routing instance."; } container default-ribs { if-feature multiple-ribs; description "Configuration of the default RIBs used by the routing instance. The default RIB for an addressed family if by default connected to all routing protocol instances supporting that address family, and always receives direct routes."; list default-rib { must "address-family=/routing/ribs/rib[name=current()/" + "rib-name]/address-family" { error-message "Address family mismatch."; description "The entry's address family MUST match that of the referenced RIB."; } key "address-family"; description "Each list entry configures the default RIB for one address family."; uses address-family-grouping; leaf rib-name { type string; mandatory "true"; description "Name of an existing RIB to be used as the default RIB for the given routing instance and address family."; } } } container interfaces { description "Configuration of the routing instance's interfaces."; list interface { key "name"; description "List of network layer interfaces assigned to the routing instance."; leaf name { type if:interface-ref; description "A reference to the name of a configured network layer interface."; } } } container routing-protocols { description "Configuration of routing protocol instances."; list routing-protocol { key "name"; description "Each entry contains configuration of a routing protocol instance."; leaf name { type string; description "An arbitrary name of the routing protocol instance."; } leaf description { type string; description "Textual description of the routing protocol instance."; } leaf enabled { type boolean; default "true"; description "Enable/disable the routing protocol instance. If this parameter is false, the parent routing protocol instance is disabled and does not appear in operational state data, despite any other configuration that might be present."; } leaf type { type identityref { base routing-protocol; } mandatory "true"; description "Type of the routing protocol - an identity derived from the 'routing-protocol' base identity."; } container connected-ribs { description "Configuration of connected RIBs."; list connected-rib { must "not(/routing/ribs/rib[name=current()/" + "preceding-sibling::connected-rib/" + "rib-name and address-family=/routing/ribs/" + "rib[name=current()/rib-name]/address-family])" { error-message "Duplicate address family for connected RIBs."; description "For each address family, there MUST NOT be more than one connected RIB."; } key "rib-name"; description "List of RIBs to which the routing protocol instance is connected (at most one RIB per address family). If no connected RIB is configured for an address family, the routing protocol is connected to the default RIB for that address family."; leaf rib-name { type rib-ref; must "../../../type != 'rt:direct' or " + "../../../../../default-ribs/ " + "default-rib/rib-name=." { error-message "The 'direct' protocol can be " + "connected only to a default RIB."; description "For the 'direct' pseudo-protocol, the connected RIB must always be a default RIB."; } description "Name of an existing RIB."; } leaf import-filter { type route-filter-ref; description "Configuration of import filter."; } leaf export-filter { type route-filter-ref; description "Configuration of export filter."; } } } container static-routes { when "../type='rt:static'" { description "This container is only valid for the 'static' routing protocol."; } description "Configuration of the 'static' pseudo-protocol. Address family specific modules augment this node with their lists of routes."; } } } } container ribs { description "Configured RIBs."; list rib { key "name"; description "Each entry represents a configured RIB identified by the 'name' key. Entries having the same key as a system-controlled entry of the list /routing-state/ribs/rib are used for configuring parameters of that entry. Other entries define additional user-controlled RIBs."; leaf name { type string; description "The name of the RIB. For system-controlled entries, the value of this leaf must be the same as the name of the corresponding entry in state data. For user-controlled entries, an arbitrary name can be used."; } uses address-family-grouping; leaf description { type string; description "Textual description of the RIB."; } container recipient-ribs { if-feature multiple-ribs; description "Configuration of recipient RIBs."; list recipient-rib { must "rib-name != ../../name" { error-message "Source and recipient RIBs are identical."; description "A RIB MUST NOT appear among its recipient RIBs."; } must "/routing/ribs/rib[name=current()/rib-name]/" + "address-family=../../address-family" { error-message "Address family mismatch."; description "Address family of the recipient RIB MUST match that of the source RIB."; } key "rib-name"; description "Each entry configures a recipient RIB."; leaf rib-name { type rib-ref; description "The name of the recipient RIB."; } leaf filter { type route-filter-ref; description "A route filter which is applied to the routes passed to the recipient RIB."; } } } } } container route-filters { description "Configuration of route filters."; list route-filter { key "name"; description "Each entry configures a named route filter."; leaf name { type string; description "The name of the route filter."; } leaf description { type string; description "Textual description of the route filter."; } leaf type { type identityref { base route-filter; } mandatory "true"; description "Type of the route filter.."; } } } } /* RPC methods */ rpc active-route { description "Return the active route that a routing-instance uses for sending packets to a destination address."; input { leaf routing-instance-name { type routing-instance-state-ref; mandatory "true"; description "Name of the routing instance whose forwarding information base is being queried. If the routing instance with name equal to the value of this parameter doesn't exist, then this operation SHALL fail with error-tag 'data-missing' and error-app-tag 'routing-instance-not-found'."; } container destination-address { description "Network layer destination address. Address family specific modules MUST augment this container with a leaf named 'address'."; uses address-family-grouping; } } output { container route { description "The active route for the specified destination. If the routing instance has no active route for the destination address, no output is returned - the server SHALL send an containing a single element . Address family specific modules MUST augment this list with appropriate route contents."; uses address-family-grouping; uses next-hop-content; uses route-metadata; } } } rpc route-count { description "Return the current number of routes in a RIB."; input { leaf rib-name { type rib-state-ref; mandatory "true"; description "Name of the RIB. If the RIB with name equal to the value of this parameter doesn't exist, then this operation SHALL fail with error-tag 'data-missing' and error-app-tag 'rib-not-found'."; } } output { leaf number-of-routes { type uint64; mandatory "true"; description "Number of routes in the RIB."; } } } }