ntsimulator/deploy/o-ran-du-rel-18/yang/ietf-inet-types.yang

   1 module ietf-inet-types {
   2
   3     yang-version 1;
   4
   5     namespace
   6       "urn:ietf:params:xml:ns:yang:ietf-inet-types";
   7
   8     prefix inet;
   9
  10     organization
  11       "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
  12
  13     contact
  14       "WG Web:   <http://tools.ietf.org/wg/netmod/>
  15     WG List:  <mailto:netmod@ietf.org>
  16
  17     WG Chair: David Kessens
  18               <mailto:david.kessens@nsn.com>
  19
  20     WG Chair: Juergen Schoenwaelder
  21               <mailto:j.schoenwaelder@jacobs-university.de>
  22
  23     Editor:   Juergen Schoenwaelder
  24               <mailto:j.schoenwaelder@jacobs-university.de>";
  25
  26     description
  27       "This module contains a collection of generally useful derived
  28     YANG data types for Internet addresses and related things.
  29
  30     Copyright (c) 2013 IETF Trust and the persons identified as
  31     authors of the code.  All rights reserved.
  32
  33     Redistribution and use in source and binary forms, with or
  34     without modification, is permitted pursuant to, and subject
  35     to the license terms contained in, the Simplified BSD License
  36     set forth in Section 4.c of the IETF Trust's Legal Provisions
  37     Relating to IETF Documents
  38     (http://trustee.ietf.org/license-info).
  39
  40     This version of this YANG module is part of RFC 6991; see
  41     the RFC itself for full legal notices.";
  42
  43     revision "2013-07-15" {
  44       description
  45         "This revision adds the following new data types:
  46       - ip-address-no-zone
  47       - ipv4-address-no-zone
  48       - ipv6-address-no-zone";
  49       reference
  50         "RFC 6991: Common YANG Data Types";
  51
  52     }
  53
  54     revision "2010-09-24" {
  55       description "Initial revision.";
  56       reference
  57         "RFC 6021: Common YANG Data Types";
  58
  59     }
  60
  61
  62     typedef ip-version {
  63       type enumeration {
  64         enum "unknown" {
  65           value 0;
  66           description
  67             "An unknown or unspecified version of the Internet
  68           protocol.";
  69         }
  70         enum "ipv4" {
  71           value 1;
  72           description
  73             "The IPv4 protocol as defined in RFC 791.";
  74         }
  75         enum "ipv6" {
  76           value 2;
  77           description
  78             "The IPv6 protocol as defined in RFC 2460.";
  79         }
  80       }
  81       description
  82         "This value represents the version of the IP protocol.
  83
  84       In the value set and its semantics, this type is equivalent
  85       to the InetVersion textual convention of the SMIv2.";
  86       reference
  87         "RFC  791: Internet Protocol
  88          RFC 2460: Internet Protocol, Version 6 (IPv6) Specification
  89          RFC 4001: Textual Conventions for Internet Network Addresses";
  90
  91     }
  92
  93     typedef dscp {
  94       type uint8 {
  95         range "0..63";
  96       }
  97       description
  98         "The dscp type represents a Differentiated Services Code Point
  99       that may be used for marking packets in a traffic stream.
 100       In the value set and its semantics, this type is equivalent
 101       to the Dscp textual convention of the SMIv2.";
 102       reference
 103         "RFC 3289: Management Information Base for the Differentiated
 104                   Services Architecture
 105          RFC 2474: Definition of the Differentiated Services Field
 106                   (DS Field) in the IPv4 and IPv6 Headers
 107          RFC 2780: IANA Allocation Guidelines For Values In
 108                   the Internet Protocol and Related Headers";
 109
 110     }
 111
 112     typedef ipv6-flow-label {
 113       type uint32 {
 114         range "0..1048575";
 115       }
 116       description
 117         "The ipv6-flow-label type represents the flow identifier or Flow
 118       Label in an IPv6 packet header that may be used to
 119       discriminate traffic flows.
 120
 121       In the value set and its semantics, this type is equivalent
 122       to the IPv6FlowLabel textual convention of the SMIv2.";
 123       reference
 124         "RFC 3595: Textual Conventions for IPv6 Flow Label
 125          RFC 2460: Internet Protocol, Version 6 (IPv6) Specification";
 126
 127     }
 128
 129     typedef port-number {
 130       type uint16 {
 131         range "0..65535";
 132       }
 133       description
 134         "The port-number type represents a 16-bit port number of an
 135       Internet transport-layer protocol such as UDP, TCP, DCCP, or
 136       SCTP.  Port numbers are assigned by IANA.  A current list of
 137       all assignments is available from <http://www.iana.org/>.
 138
 139       Note that the port number value zero is reserved by IANA.  In
 140       situations where the value zero does not make sense, it can
 141       be excluded by subtyping the port-number type.
 142       In the value set and its semantics, this type is equivalent
 143       to the InetPortNumber textual convention of the SMIv2.";
 144       reference
 145         "RFC  768: User Datagram Protocol
 146          RFC  793: Transmission Control Protocol
 147          RFC 4960: Stream Control Transmission Protocol
 148          RFC 4340: Datagram Congestion Control Protocol (DCCP)
 149          RFC 4001: Textual Conventions for Internet Network Addresses";
 150
 151     }
 152
 153     typedef as-number {
 154       type uint32;
 155       description
 156         "The as-number type represents autonomous system numbers
 157       which identify an Autonomous System (AS).  An AS is a set
 158       of routers under a single technical administration, using
 159       an interior gateway protocol and common metrics to route
 160       packets within the AS, and using an exterior gateway
 161       protocol to route packets to other ASes.  IANA maintains
 162       the AS number space and has delegated large parts to the
 163       regional registries.
 164
 165       Autonomous system numbers were originally limited to 16
 166       bits.  BGP extensions have enlarged the autonomous system
 167       number space to 32 bits.  This type therefore uses an uint32
 168       base type without a range restriction in order to support
 169       a larger autonomous system number space.
 170
 171       In the value set and its semantics, this type is equivalent
 172       to the InetAutonomousSystemNumber textual convention of
 173       the SMIv2.";
 174       reference
 175         "RFC 1930: Guidelines for creation, selection, and registration
 176                   of an Autonomous System (AS)
 177          RFC 4271: A Border Gateway Protocol 4 (BGP-4)
 178          RFC 4001: Textual Conventions for Internet Network Addresses
 179          RFC 6793: BGP Support for Four-Octet Autonomous System (AS)
 180                   Number Space";
 181
 182     }
 183
 184     typedef ip-address {
 185       type union {
 186         type ipv4-address;
 187         type ipv6-address;
 188       }
 189       description
 190         "The ip-address type represents an IP address and is IP
 191       version neutral.  The format of the textual representation
 192       implies the IP version.  This type supports scoped addresses
 193       by allowing zone identifiers in the address format.";
 194       reference
 195         "RFC 4007: IPv6 Scoped Address Architecture";
 196
 197     }
 198
 199     typedef ipv4-address {
 200       type string {
 201         pattern
 202           '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}'
 203             + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'
 204             + '(%[\p{N}\p{L}]+)?';
 205       }
 206       description
 207         "The ipv4-address type represents an IPv4 address in
 208        dotted-quad notation.  The IPv4 address may include a zone
 209        index, separated by a % sign.
 210
 211        The zone index is used to disambiguate identical address
 212        values.  For link-local addresses, the zone index will
 213        typically be the interface index number or the name of an
 214        interface.  If the zone index is not present, the default
 215        zone of the device will be used.
 216
 217        The canonical format for the zone index is the numerical
 218        format";
 219     }
 220
 221     typedef ipv6-address {
 222       type string {
 223         pattern
 224           '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}'
 225             + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|'
 226             + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}'
 227             + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))'
 228             + '(%[\p{N}\p{L}]+)?';
 229         pattern
 230           '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|'
 231             + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)'
 232             + '(%.+)?';
 233       }
 234       description
 235         "The ipv6-address type represents an IPv6 address in full,
 236       mixed, shortened, and shortened-mixed notation.  The IPv6
 237       address may include a zone index, separated by a % sign.
 238
 239       The zone index is used to disambiguate identical address
 240       values.  For link-local addresses, the zone index will
 241       typically be the interface index number or the name of an
 242       interface.  If the zone index is not present, the default
 243       zone of the device will be used.
 244
 245
 246
 247       The canonical format of IPv6 addresses uses the textual
 248       representation defined in Section 4 of RFC 5952.  The
 249       canonical format for the zone index is the numerical
 250       format as described in Section 11.2 of RFC 4007.";
 251       reference
 252         "RFC 4291: IP Version 6 Addressing Architecture
 253          RFC 4007: IPv6 Scoped Address Architecture
 254          RFC 5952: A Recommendation for IPv6 Address Text
 255                   Representation";
 256
 257     }
 258
 259     typedef ip-address-no-zone {
 260       type union {
 261         type ipv4-address-no-zone;
 262         type ipv6-address-no-zone;
 263       }
 264       description
 265         "The ip-address-no-zone type represents an IP address and is
 266       IP version neutral.  The format of the textual representation
 267       implies the IP version.  This type does not support scoped
 268       addresses since it does not allow zone identifiers in the
 269       address format.";
 270       reference
 271         "RFC 4007: IPv6 Scoped Address Architecture";
 272
 273     }
 274
 275     typedef ipv4-address-no-zone {
 276       type ipv4-address {
 277         pattern '[0-9\.]*';
 278       }
 279       description
 280         "An IPv4 address without a zone index.  This type, derived from
 281        ipv4-address, may be used in situations where the zone is
 282        known from the context and hence no zone index is needed.";
 283     }
 284
 285     typedef ipv6-address-no-zone {
 286       type ipv6-address {
 287         pattern '[0-9a-fA-F:\.]*';
 288       }
 289       description
 290         "An IPv6 address without a zone index.  This type, derived from
 291        ipv6-address, may be used in situations where the zone is
 292        known from the context and hence no zone index is needed.";
 293       reference
 294         "RFC 4291: IP Version 6 Addressing Architecture
 295          RFC 4007: IPv6 Scoped Address Architecture
 296          RFC 5952: A Recommendation for IPv6 Address Text
 297                   Representation";
 298
 299     }
 300
 301     typedef ip-prefix {
 302       type union {
 303         type ipv4-prefix;
 304         type ipv6-prefix;
 305       }
 306       description
 307         "The ip-prefix type represents an IP prefix and is IP
 308       version neutral.  The format of the textual representations
 309       implies the IP version.";
 310     }
 311
 312     typedef ipv4-prefix {
 313       type string {
 314         pattern
 315           '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}'
 316             + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'
 317             + '/(([0-9])|([1-2][0-9])|(3[0-2]))';
 318       }
 319       description
 320         "The ipv4-prefix type represents an IPv4 address prefix.
 321       The prefix length is given by the number following the
 322       slash character and must be less than or equal to 32.
 323
 324       A prefix length value of n corresponds to an IP address
 325       mask that has n contiguous 1-bits from the most
 326       significant bit (MSB) and all other bits set to 0.
 327
 328       The canonical format of an IPv4 prefix has all bits of
 329       the IPv4 address set to zero that are not part of the
 330       IPv4 prefix.";
 331     }
 332
 333     typedef ipv6-prefix {
 334       type string {
 335         pattern
 336           '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}'
 337             + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|'
 338             + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}'
 339             + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))'
 340             + '(/(([0-9])|([0-9]{2})|(1[0-1][0-9])|(12[0-8])))';
 341         pattern
 342           '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|'
 343             + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)'
 344             + '(/.+)';
 345       }
 346       description
 347         "The ipv6-prefix type represents an IPv6 address prefix.
 348       The prefix length is given by the number following the
 349       slash character and must be less than or equal to 128.
 350
 351       A prefix length value of n corresponds to an IP address
 352       mask that has n contiguous 1-bits from the most
 353       significant bit (MSB) and all other bits set to 0.
 354
 355       The IPv6 address should have all bits that do not belong
 356       to the prefix set to zero.
 357
 358       The canonical format of an IPv6 prefix has all bits of
 359       the IPv6 address set to zero that are not part of the
 360       IPv6 prefix.  Furthermore, the IPv6 address is represented
 361       as defined in Section 4 of RFC 5952.";
 362       reference
 363         "RFC 5952: A Recommendation for IPv6 Address Text
 364                   Representation";
 365
 366     }
 367
 368     typedef domain-name {
 369       type string {
 370         length "1..253";
 371         pattern
 372           '((([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.)*'
 373             + '([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.?)'
 374             + '|\.';
 375       }
 376       description
 377         "The domain-name type represents a DNS domain name.  The
 378       name SHOULD be fully qualified whenever possible.
 379
 380       Internet domain names are only loosely specified.  Section
 381       3.5 of RFC 1034 recommends a syntax (modified in Section
 382       2.1 of RFC 1123).  The pattern above is intended to allow
 383       for current practice in domain name use, and some possible
 384       future expansion.  It is designed to hold various types of
 385       domain names, including names used for A or AAAA records
 386       (host names) and other records, such as SRV records.  Note
 387       that Internet host names have a stricter syntax (described
 388       in RFC 952) than the DNS recommendations in RFCs 1034 and
 389       1123, and that systems that want to store host names in
 390       schema nodes using the domain-name type are recommended to
 391       adhere to this stricter standard to ensure interoperability.
 392
 393       The encoding of DNS names in the DNS protocol is limited
 394       to 255 characters.  Since the encoding consists of labels
 395       prefixed by a length bytes and there is a trailing NULL
 396       byte, only 253 characters can appear in the textual dotted
 397       notation.
 398
 399       The description clause of schema nodes using the domain-name
 400       type MUST describe when and how these names are resolved to
 401       IP addresses.  Note that the resolution of a domain-name value
 402       may require to query multiple DNS records (e.g., A for IPv4
 403       and AAAA for IPv6).  The order of the resolution process and
 404       which DNS record takes precedence can either be defined
 405       explicitly or may depend on the configuration of the
 406       resolver.
 407
 408       Domain-name values use the US-ASCII encoding.  Their canonical
 409       format uses lowercase US-ASCII characters.  Internationalized
 410       domain names MUST be A-labels as per RFC 5890.";
 411       reference
 412         "RFC  952: DoD Internet Host Table Specification
 413          RFC 1034: Domain Names - Concepts and Facilities
 414          RFC 1123: Requirements for Internet Hosts -- Application
 415                   and Support
 416          RFC 2782: A DNS RR for specifying the location of services
 417                   (DNS SRV)
 418          RFC 5890: Internationalized Domain Names in Applications
 419                   (IDNA): Definitions and Document Framework";
 420
 421     }
 422
 423     typedef host {
 424       type union {
 425         type ip-address;
 426         type domain-name;
 427       }
 428       description
 429         "The host type represents either an IP address or a DNS
 430       domain name.";
 431     }
 432
 433     typedef uri {
 434       type string;
 435       description
 436         "The uri type represents a Uniform Resource Identifier
 437       (URI) as defined by STD 66.
 438
 439       Objects using the uri type MUST be in US-ASCII encoding,
 440       and MUST be normalized as described by RFC 3986 Sections
 441       6.2.1, 6.2.2.1, and 6.2.2.2.  All unnecessary
 442       percent-encoding is removed, and all case-insensitive
 443       characters are set to lowercase except for hexadecimal
 444       digits, which are normalized to uppercase as described in
 445       Section 6.2.2.1.
 446
 447       The purpose of this normalization is to help provide
 448       unique URIs.  Note that this normalization is not
 449       sufficient to provide uniqueness.  Two URIs that are
 450       textually distinct after this normalization may still be
 451       equivalent.
 452
 453       Objects using the uri type may restrict the schemes that
 454       they permit.  For example, 'data:' and 'urn:' schemes
 455       might not be appropriate.
 456
 457       A zero-length URI is not a valid URI.  This can be used to
 458       express 'URI absent' where required.
 459
 460       In the value set and its semantics, this type is equivalent
 461       to the Uri SMIv2 textual convention defined in RFC 5017.";
 462       reference
 463         "RFC 3986: Uniform Resource Identifier (URI): Generic Syntax
 464          RFC 3305: Report from the Joint W3C/IETF URI Planning Interest
 465                   Group: Uniform Resource Identifiers (URIs), URLs,
 466                   and Uniform Resource Names (URNs): Clarifications
 467                   and Recommendations
 468          RFC 5017: MIB Textual Conventions for Uniform Resource
 469                   Identifiers (URIs)";
 470
 471     }
 472   }  // module ietf-inet-types