netconfcentral logo

ietf-babel

HTML

ietf-babel@2020-06-28



  module ietf-babel {

    yang-version 1.1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-babel";

    prefix babel;

    import ietf-yang-types {
      prefix yt;
      reference
        "RFC 6991: Common YANG Data Types.";


    }
    import ietf-inet-types {
      prefix inet;
      reference
        "RFC 6991: Common YANG Data Types.";


    }
    import ietf-interfaces {
      prefix if;
      reference
        "RFC 8343: A YANG Data Model for Interface Management";


    }
    import ietf-routing {
      prefix rt;
      reference
        "RFC 8349: YANG Routing Management";


    }

    organization
      "IETF Babel routing protocol Working Group";

    contact
      "WG Web: http://tools.ietf.org/wg/babel/
     WG List: babel@ietf.org

     Editor: Mahesh Jethanandani
             mjethanandani@gmail.com
     Editor: Barbara Stark
             bs7652@att.com";

    description
      "This YANG module defines a model for the Babel routing
     protocol.

     The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL
     NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED',
     'MAY', and 'OPTIONAL' in this document are to be interpreted as
     described in BCP 14 (RFC 2119) (RFC 8174) when, and only when,
     they appear in all capitals, as shown here.

     Copyright (c) 2020 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
     (https://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC XXXX
     (https://www.rfc-editor.org/info/rfcXXXX); see the RFC itself
     for full legal notices.";

    revision "2020-06-28" {
      description "Initial version.";
      reference
        "RFC XXXX: Babel YANG Data Model.";

    }


    feature two-out-of-three-supported {
      description
        "This implementation supports two-out-of-three metric
       comp algorithm.";
    }

    feature etx-supported {
      description
        "This implementation supports Expected Transmission Count
       (ETX) metric comp algorithm.";
    }

    feature mac-supported {
      description
        "This implementation supports MAC based security.";
    }

    feature dtls-supported {
      description
        "This implementation supports DTLS based security.";
    }

    feature hmac-sha256-supported {
      description
        "This implementation supports hmac-sha256 MAC algorithm.";
    }

    feature blake2s-supported {
      description
        "This implementation supports blake2 MAC algorithm.";
    }

    feature x-509-supported {
      description
        "This implementation supports x-509 certificate type.";
    }

    feature raw-public-key-supported {
      description
        "This implementation supports raw-public-key certificate type.";
    }

    identity metric-comp-algorithms {
      base 
      description
        "Base identity from which all Babel metric comp algorithms
       are derived.";
    }

    identity two-out-of-three {
      base metric-comp-algorithms;
      description "2-out-of-3 algorithm.";
    }

    identity etx {
      base metric-comp-algorithms;
      description
        "Expected Transmission Count.";
    }

    identity mac-algorithms {
      base 
      description
        "Base identity for all Babel MAC algorithms.";
    }

    identity hmac-sha256 {
      base mac-algorithms;
      description
        "HMAC-SHA256 algorithm supported.";
      reference
        "RFC 4868: Using HMAC-SHA-256, HMAC-SHA-384, and HMAC-SHA-512
        with IPsec.";

    }

    identity blake2s {
      base mac-algorithms;
      description
        "BLAKE2s algorithm supported.";
      reference
        "RFC 7693: The BLAKE2 Cryptographic Hash and Message
        Authentication Code (MAC).";

    }

    identity dtls-cert-types {
      base 
      description
        "Base identity for Babel DTLS certificate types.";
    }

    identity x-509 {
      base dtls-cert-types;
      description "X.509 certificate type.";
    }

    identity raw-public-key {
      base dtls-cert-types;
      description "Raw Public Key type.";
    }

    identity babel {
      base rt:routing-protocol;
      description "Babel routing protocol";
    }

    grouping routes {
      description
        "Common grouping for routing used in RIB.";
      list routes {
        key "prefix";
        config false;
        description
          "A set of babel-route-obj objects. Includes received and
         routes routes.";
        reference
          "RFC ZZZZ: Babel Information Model, Section 3.1.";

        leaf prefix {
          type inet:ip-prefix;
          description
            "Prefix (expressed in ip-address/prefix-length format) for
           which this route is advertised.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6.";

        }

        leaf router-id {
          type binary;
          description
            "router-id of the source router for which this route is
           advertised.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6.";

        }

        leaf neighbor {
          type leafref {
            path "/rt:routing/rt:control-plane-protocols/rt:control-plane-protocol/babel/interfaces/neighbor-objects/neighbor-address";
          }
          description
            "Reference to the neighbor-objects entry for the neighbor
           that advertised this route.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6.";

        }

        leaf received-metric {
          type uint16;
          description
            "The metric with which this route was advertised by the
           neighbor, or maximum value (infinity) to indicate the
           route was recently retracted and is temporarily
           unreachable. This metric will be 0 (zero) if the route
           was not received from a neighbor but was generated
           through other means. At least one of
           calculated-metric or received-metric MUST be non-NULL.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6,
             draft-ietf-babel-rfc6126bis: The Babel Routing Protocol,
            			     Section 3.5.5.";

        }

        leaf calculated-metric {
          type uint16;
          description
            "A calculated metric for this route. How the metric is
           calculated is implementation-specific. Maximum value
           (infinity) indicates the route was recently retracted
           and is temporarily unreachable. At least one of
           calculated-metric or received-metric MUST be non-NULL.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6,
             draft-ietf-babel-rfc6126bis: The Babel Routing Protocol,
            			     Section 3.5.5.";

        }

        leaf seqno {
          type uint16;
          description
            "The sequence number with which this route was advertised.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6.";

        }

        leaf next-hop {
          type inet:ip-address;
          description
            "The next-hop address of this route. This will be empty if
           this route has no next-hop address.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6.";

        }

        leaf feasible {
          type boolean;
          description
            "A boolean flag indicating whether this route is feasible.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6,
             draft-ietf-babel-rfc6126bis, The Babel Routing Protocol,
            Section 3.5.1.";

        }

        leaf selected {
          type boolean;
          description
            "A boolean flag indicating whether this route is selected,
           i.e., whether it is currently being used for forwarding and
           is being advertised.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.6.";

        }
      }  // list routes
    }  // grouping routes

    augment /rt:routing/rt:control-plane-protocols/rt:control-plane-protocol {
      when
        "derived-from-or-self(rt:type, 'babel')" {
        description
          "Augmentation is valid only when the instance of routing type
         is of type 'babel'.";
      }
      description
        "Augment the routing module to support a common structure
       between routing protocols.";
      reference
        "YANG Routing Management, RFC 8349, Lhotka & Lindem, March
        2018.";

      container babel {
        presence "A Babel container.";
        description
          "Babel Information Objects.";
        reference
          "RFC ZZZZ: Babel Information Model, Section 3.";

        leaf version {
          type string;
          config false;
          description
            "The name and version of this implementation of the Babel
           protocol.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.1.";

        }

        leaf enable {
          type boolean;
          mandatory true;
          description
            "When written, it configures whether the protocol should be
           enabled. A read from the <running> or <intended> datastore
           therefore indicates the configured administrative value of
           whether the protocol is enabled or not.

           A read from the <operational> datastore indicates whether
           the protocol is actually running or not, i.e. it indicates
           the operational state of the protocol.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.1.";

        }

        leaf router-id {
          type binary;
          config false;
          description
            "Every Babel speaker is assigned a router-id, which is an
           arbitrary string of 8 octets that is assumed to be unique
           across the routing domain";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.1,
             draft-ietf-babel-rfc6126bis: The Babel Routing Protocol,
            			     Section 3.";

        }

        leaf seqno {
          type uint16;
          config false;
          description
            "Sequence number included in route updates for routes
           originated by this node.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.1.";

        }

        leaf stats-enable {
          type boolean;
          description
            "Indicates whether statistics collection is enabled (true)
           or disabled (false) on all interfaces.";
        }

        container constants {
          description
            "Babel Constants object.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.1.";

          leaf udp-port {
            type inet:port-number;
            default "6696";
            description
              "UDP port for sending and receiving Babel messages. The
             default port is 6696.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.2.";

          }

          leaf mcast-group {
            type inet:ip-address;
            default "ff02::1:6";
            description
              "Multicast group for sending and receiving multicast
             announcements on IPv6.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.2.";

          }
        }  // container constants

        list interfaces {
          key "reference";
          description
            "A set of Babel Interface objects.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.3.";

          leaf reference {
            type if:interface-ref;
            description
              "References the name of the interface over which Babel
             packets are sent and received.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf enable {
            type boolean;
            default "true";
            description
              "If true, babel sends and receives messages on this
             interface. If false, babel messages received on this
             interface are ignored and none are sent.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf metric-algorithm {
            type identityref {
              base metric-comp-algorithms;
            }
            mandatory true;
            description
              "Indicates the metric computation algorithm used on this
             interface. The value MUST be one of those identities
             based on 'metric-comp-algorithms'.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.X.";

          }

          leaf split-horizon {
            type boolean;
            description
              "Indicates whether or not the split horizon optimization
             is used when calculating metrics on this interface.
             A value of true indicates split horizon optimization
             is used.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.X.";

          }

          leaf mcast-hello-seqno {
            type uint16;
            config false;
            description
              "The current sequence number in use for multicast hellos
             sent on this interface.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf mcast-hello-interval {
            type uint16;
            units "centiseconds";
            description
              "The current multicast hello interval in use for hellos
             sent on this interface.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf update-interval {
            type uint16;
            units "centiseconds";
            description
              "The current update interval in use for this interface.
             Units are centiseconds.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf mac-enable {
            type boolean;
            description
              "Indicates whether the MAC security mechanism is enabled
             (true) or disabled (false).";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf-list mac-key-sets {
            type leafref {
              path "../../mac/name";
            }
            description
              "List of references to the mac entries that apply
             to this interface. When an interface instance is
             created, all mac instances with default-apply 'true'
             will be included in this list.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf mac-verify {
            type boolean;
            description
              "A Boolean flag indicating whether MAC hashes in
             incoming Babel packets are required to be present and
             are verified.  If this parameter is 'true', incoming
             packets are required to have a valid MAC hash.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf dtls-enable {
            type boolean;
            description
              "Indicates whether the DTLS security mechanism is enabled
             (true) or disabled (false).";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf-list dtls-certs {
            type leafref {
              path "../../dtls/name";
            }
            description
              "List of references to the dtls entries that apply to
             this interface.  When an interface instance
             is created, all dtls instances with default-apply
             'true' will be included in this list.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf dtls-cached-info {
            type boolean;
            description
              "Indicates whether the cached_info extension is included
             in ClientHello and ServerHello packets. The extension
             is included if the value is 'true'.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf-list dtls-cert-prefer {
            type leafref {
              path "../../dtls/certs/type";
            }
            ordered-by user;
            description
              "List of supported certificate types, in order of
             preference. The values MUST be among those listed in
             dtls-cert-types. This list is used to populate the
             server_certificate_type extension in a Client Hello.
             Values that are present in at least one instance in the
             certs object under dtls of a referenced dtls instance
             and that have a non-empty private-key will be used to
             populate the client_certificate_type extension in a
             Client Hello.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf packet-log-enable {
            type boolean;
            description
              "If true, logging of babel packets received on this
             interface is enabled; if false, babel packets are not
             logged.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          leaf packet-log {
            type inet:uri;
            config false;
            description
              "A reference or url link to a file that contains a
             timestamped log of packets received and sent on
             udp-port on this interface. The [libpcap] file
             format with .pcap file extension SHOULD be supported for
             packet log files. Logging is enabled / disabled by
             packet-log-enable.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

          }

          container stats {
            config false;
            description
              "Statistics collection object for this interface.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.3.";

            leaf sent-mcast-hello {
              type yt:counter32;
              description
                "A count of the number of multicast Hello packets sent
               on this interface.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.4.";

            }

            leaf sent-mcast-update {
              type yt:counter32;
              description
                "A count of the number of multicast update packets sent
               on this interface.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.4.";

            }

            leaf sent-ucast-hello {
              type yt:counter32;
              description
                "A count of the number of unicast Hello packets sent
               to this neighbor.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.6.";

            }

            leaf sent-ucast-update {
              type yt:counter32;
              description
                "A count of the number of unicast update packets sent
               to this neighbor.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.6.";

            }

            leaf sent-ihu {
              type yt:counter32;
              description
                "A count of the number of IHU packets sent to this
               neighbor.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.6.";

            }

            leaf received-packets {
              type yt:counter32;
              description
                "A count of the number of Babel packets received on
               this interface.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.4.";

            }

            action reset {
              description
                "The information model [RFC ZZZZ] defines reset
               action as a system-wide reset of Babel statistics.
               In YANG the reset action is associated with the
               container where the action is defined. In this case
               the action is associated with the stats container
               inside an interface. The action will therefore
               reset statistics at an interface level.

               Implementations that want to support a system-wide
               reset of Babel statistics need to call this action
               for every instance of the interface.";
              input {
                leaf reset-at {
                  type yt:date-and-time;
                  description
                    "The time when the reset was issued.";
                }
              }

              output {
                leaf reset-finished-at {
                  type yt:date-and-time;
                  description
                    "The time when the reset finished.";
                }
              }
            }  // rpc reset
          }  // container stats

          list neighbor-objects {
            key "neighbor-address";
            config false;
            description
              "A set of Babel Neighbor Object.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.5.";

            leaf neighbor-address {
              type inet:ip-address;
              description
                "IPv4 or v6 address the neighbor sends packets from.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf hello-mcast-history {
              type string;
              description
                "The multicast Hello history of whether or not the
               multicast Hello packets prior to exp-mcast-
               hello-seqno were received, with a '1' for the most
               recent Hello placed in the most significant bit and
               prior Hellos shifted right (with '0' bits placed
               between prior Hellos and most recent Hello for any
               not-received Hellos); represented as a string using
               utf-8 encoded hex digits where a '1' bit = Hello
               received and a '0' bit = Hello not received.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf hello-ucast-history {
              type string;
              description
                "The unicast Hello history of whether or not the
               unicast Hello packets prior to exp-ucast-hello-seqno
               were received, with a '1' for the most
               recent Hello placed in the most significant bit and
               prior Hellos shifted right (with '0' bits placed
               between prior Hellos and most recent Hello for any
               not-received Hellos); represented as a string using
               utf-8 encoded hex digits where a '1' bit = Hello
               received and a '0' bit = Hello not received.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf txcost {
              type int32;
              default "0";
              description
                "Transmission cost value from the last IHU packet
               received from this neighbor, or maximum value
               (infinity) to indicate the IHU hold timer for this
               neighbor has expired description.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf exp-mcast-hello-seqno {
              type uint16;
              default "0";
              description
                "Expected multicast Hello sequence number of next Hello
               to be received from this neighbor; if multicast Hello
               packets are not expected, or processing of multicast
               packets is not enabled, this MUST be NULL.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf exp-ucast-hello-seqno {
              type uint16;
              default "0";
              description
                "Expected unicast Hello sequence number of next Hello to
               be received from this neighbor; if unicast Hello
               packets are not expected, or processing of unicast
               packets is not enabled, this MUST be NULL.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf ucast-hello-seqno {
              type uint16;
              description
                "Expected unicast Hello sequence number of next Hello
               to be received from this neighbor. If unicast Hello
               packets are not expected, or processing of unicast
               packets is not enabled, this MUST be 0.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf ucast-hello-interval {
              type uint16;
              units "centiseconds";
              description
                "The current interval in use for unicast hellos sent to
               this neighbor. Units are centiseconds.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf rxcost {
              type int32;
              description
                "Reception cost calculated for this neighbor. This value
               is usually derived from the Hello history, which may be
               combined with other data, such as statistics maintained
               by the link layer. The rxcost is sent to a neighbor in
               each IHU.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }

            leaf cost {
              type int32;
              description
                "Link cost is computed from the values maintained in
               the neighbor table. The statistics kept in the neighbor
               table about the reception of Hellos, and the txcost
               computed from received IHU packets.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.5.";

            }
          }  // list neighbor-objects
        }  // list interfaces

        list mac {
          key "name";
          description
            "A mac object. If this object is implemented, it
           provides access to parameters related to the MAC security
           mechanism.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.7.";

          leaf name {
            type string;
            description
              "A string that uniquely identifies the mac object.";
          }

          leaf default-apply {
            type boolean;
            description
              "A Boolean flag indicating whether this mac
             instance is applied to all new interfaces, by default.
             If 'true', this instance is applied to new
             interfaces instances at the time they are created,
             by including it in the mac-key-sets list under
             interfaces. If 'false', this instance is not applied
             to new interfaces instances when they are created.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.7.";

          }

          list keys {
            key "name";
            min-elements 1;
            description
              "A set of keys objects.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.8.";

            leaf name {
              type string;
              mandatory true;
              description
                "A unique name for this MAC key that can be used to
               identify the key in this object instance, since the key
               value is not allowed to be read. This value can only be
               provided when this instance is created, and is not
               subsequently writable.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.8.";

            }

            leaf use-sign {
              type boolean;
              mandatory true;
              description
                "Indicates whether this key value is used to sign sent
               Babel packets. Sent packets are signed using this key
               if the value is 'true'. If the value is 'false', this
               key is not used to sign sent Babel packets.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.8.";

            }

            leaf use-verify {
              type boolean;
              mandatory true;
              description
                "Indicates whether this key value is used to verify
               incoming Babel packets. This key is used to verify
               incoming packets if the value is 'true'. If the value
               is 'false', no MAC is computed from this key for
               comparing an incoming packet.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.8.";

            }

            leaf value {
              type binary;
              mandatory true;
              description
                "The value of the MAC key. An implementation MUST NOT
               allow this parameter to be read. This can be done by
               always providing an empty string, or through
               permissions, or other means. This value MUST be
               provided when this instance is created, and is not
               subsequently writable.

               This value is of a length suitable for the associated
               algorithm. If the algorithm is based on
               the HMAC construction [RFC2104], the length MUST be
               between 0 and the block size of the underlying hash
               inclusive (where 'HMAC-SHA256' block size is 64
               bytes as described in [RFC4868]). If the algorithm
               is 'BLAKE2s', the length MUST be between 0 and 32
               bytes inclusive, as described in [RFC7693].";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.8,
                 RFC 2104: HMAC: Keyed-Hashing for Message
                	  Authentication
                 RFC 4868: Using HMAC-SHA-256, HMAC-SHA-384, and
                	  HMAC-SHA-512 with IPsec,
                 RFC 7693: The BLAKE2 Cryptographic Hash and Message
                	  Authentication Code (MAC).";

            }

            leaf algorithm {
              type identityref {
                base mac-algorithms;
              }
              description
                "The name of the MAC algorithm used with this key. The
               value MUST be the same as one of the enumerations
               listed in the mac-algorithms parameter.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.8.";

            }

            action test {
              description
                "An operation that allows the MAC key and hash
               algorithm to be tested to see if they produce an
               expected outcome. Input to this operation is a
               binary string. The implementation is expected to
               create a hash of this string using the value and
               the algorithm. The output of this operation is
               the resulting hash, as a binary string.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.8.";

              input {
                leaf test-string {
                  type binary;
                  mandatory true;
                  description
                    "Input to this operation is a binary string.
                   The implementation is expected to create
                   a hash of this string using the value and
                   the algorithm.";
                  reference
                    "RFC ZZZZ: Babel Information Model, Section 3.8.";

                }
              }

              output {
                leaf resulting-hash {
                  type binary;
                  mandatory true;
                  description
                    "The output of this operation is
                   the resulting hash, as a binary string.";
                  reference
                    "RFC ZZZZ: Babel Information Model, Section 3.8.";

                }
              }
            }  // rpc test
          }  // list keys
        }  // list mac

        list dtls {
          key "name";
          description
            "A dtls object. If this object is implemented,
           it provides access to parameters related to the DTLS
           security mechanism.";
          reference
            "RFC ZZZZ: Babel Information Model, Section 3.9";

          leaf name {
            type string;
            description
              "A string that uniquely identifies a dtls object.";
          }

          leaf default-apply {
            type boolean;
            mandatory true;
            description
              "A Boolean flag indicating whether this dtls
             instance is applied to all new interfaces, by default. If
             'true', this instance is applied to new interfaces
             instances at the time they are created, by including it
             in the dtls-certs list under interfaces. If 'false',
             this instance is not applied to new interfaces
             instances when they are created.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.9.";

          }

          list certs {
            key "name";
            min-elements 1;
            description
              "A set of cert objects. This contains
             both certificates for this implementation to present
             for authentication, and to accept from others.
             Certificates with a non-empty private-key
             can be presented by this implementation for
             authentication.";
            reference
              "RFC ZZZZ: Babel Information Model, Section 3.10.";

            leaf name {
              type string;
              description
                "A unique name for this DTLS certificate that can be
               used to identify the certificate in this object
               instance, since the value is too long to be useful
               for identification. This value MUST NOT be empty
               and can only be provided when this instance is created
               (i.e., it is not subsequently writable).";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.10.";

            }

            leaf value {
              type string;
              mandatory true;
              description
                "The DTLS certificate in PEM format [RFC7468]. This
               value can only be provided when this instance is
               created, and is not subsequently writable.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.10.";

            }

            leaf type {
              type identityref {
                base dtls-cert-types;
              }
              mandatory true;
              description
                "The name of the certificate type of this object
               instance. The value MUST be the same as one of the
               enumerations listed in the dtls-cert-types
               parameter. This value can only be provided when this
               instance is created, and is not subsequently writable.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.10.";

            }

            leaf private-key {
              type binary;
              mandatory true;
              description
                "The value of the private key. If this is non-empty,
               this certificate can be used by this implementation to
               provide a certificate during DTLS handshaking. An
               implementation MUST NOT allow this parameter to be
               read. This can be done by always providing an empty
               string, or through permissions, or other means. This
               value can only be provided when this instance is
               created, and is not subsequently writable.";
              reference
                "RFC ZZZZ: Babel Information Model, Section 3.10.";

            }

            action test {
              input {
                leaf test-string {
                  type binary;
                  mandatory true;
                  description
                    "The test string on which this test has to be
                   performed.";
                }
              }

              output {
                leaf resulting-hash {
                  type binary;
                  mandatory true;
                  description
                    "The output of this operation is a binary string,
                   and is the resulting hash computed using the
                   certificate public key, and the SHA-256
                   hash algorithm.";
                }
              }
            }  // rpc test
          }  // list certs
        }  // list dtls

        uses routes;
      }  // container babel
    }
  }  // module ietf-babel

Summary

  
  
Organization IETF Babel routing protocol Working Group
  
Module ietf-babel
Version 2020-06-28
File ietf-babel@2020-06-28.yang
  
Prefix babel
Namespace urn:ietf:params:xml:ns:yang:ietf-babel
  
Cooked /cookedmodules/ietf-babel/2020-06-28
YANG /src/ietf-babel@2020-06-28.yang
XSD /xsd/ietf-babel@2020-06-28.xsd
  
Abstract This YANG module defines a model for the Babel routing protocol. The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL ...
  
Contact
WG Web: http://tools.ietf.org/wg/babel/
WG List: babel@ietf.org

Editor: Mahesh Jethanandani
	mjethanandani@gmail.com
Editor: Barbara Stark
	bs7652@att.com

Description

 
This YANG module defines a model for the Babel routing
protocol.

The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL
NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED',
'MAY', and 'OPTIONAL' in this document are to be interpreted as
described in BCP 14 (RFC 2119) (RFC 8174) when, and only when,
they appear in all capitals, as shown here.

Copyright (c) 2020 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
(https://trustee.ietf.org/license-info).

This version of this YANG module is part of RFC XXXX
(https://www.rfc-editor.org/info/rfcXXXX); see the RFC itself
for full legal notices.

Groupings

Grouping Objects Abstract
routes routes Common grouping for routing used in RIB.