opendaylight/config/yang-jmx-generator/src/test/resources/ietf-inet-types.yang

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