Interface IetfLispAddressTypesData

  • All Superinterfaces:
    org.opendaylight.yangtools.yang.binding.DataRoot

    @Generated("mdsal-binding-generator")
    public interface IetfLispAddressTypesData
    extends org.opendaylight.yangtools.yang.binding.DataRoot
    This YANG module defines the LISP Canonical Address Formats (LCAF) for LISP. module can be extended by vendors to define vendor-specific parameters. Copyright (c) 2014 IETF Trust and the persons identified as authors of the All rights reserved. Redistribution and use in source and binary forms, with or without modification, is permitted pursuant to, and subject to the license 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 of RFC 6338; see the RFC itself for full legal notices.

    This class represents the following YANG schema fragment defined in module ietf-lisp-address-types

     module ietf-lisp-address-types {
       namespace urn:ietf:params:xml:ns:yang:ietf-lisp-address-types;
       prefix laddr;
       import ietf-inet-types {
         prefix inet;
         revision-date 2013-07-15;
       }
       import ietf-yang-types {
         prefix yang;
         revision-date 2013-07-15;
       }
       revision 2015-11-05 {
       }
       identity lisp-address-family {
       }
       identity no-address-afi {
         base lisp-address-family;
       }
       identity ipv4-afi {
         base lisp-address-family;
       }
       identity ipv4-prefix-afi {
         base lisp-address-family;
       }
       identity ipv6-afi {
         base lisp-address-family;
       }
       identity ipv6-prefix-afi {
         base lisp-address-family;
       }
       identity mac-afi {
         base lisp-address-family;
       }
       identity distinguished-name-afi {
         base lisp-address-family;
       }
       identity as-number-afi {
         base lisp-address-family;
       }
       identity lcaf {
         base lisp-address-family;
       }
       identity null-address-lcaf {
         base lcaf;
       }
       identity afi-list-lcaf {
         base lcaf;
       }
       identity instance-id-lcaf {
         base lcaf;
       }
       identity as-number-lcaf {
         base lcaf;
       }
       identity application-data-lcaf {
         base lcaf;
       }
       identity geo-coordinates-lcaf {
         base lcaf;
       }
       identity opaque-key-lcaf {
         base lcaf;
       }
       identity nat-traversal-lcaf {
         base lcaf;
       }
       identity nonce-locator-lcaf {
         base lcaf;
       }
       identity multicast-info-lcaf {
         base lcaf;
       }
       identity explicit-locator-path-lcaf {
         base lcaf;
       }
       identity security-key-lcaf {
         base lcaf;
       }
       identity source-dest-key-lcaf {
         base lcaf;
       }
       identity replication-list-lcaf {
         base lcaf;
       }
       identity json-data-model-lcaf {
         base lcaf;
       }
       identity key-value-address-lcaf {
         base lcaf;
       }
       identity encapsulation-format-lcaf {
         base lcaf;
       }
       identity service-path-lcaf {
         base lcaf;
       }
       typedef instance-id-type {
         type uint32 {
           range 0..16777215;
         }
       }
       typedef service-path-id-type {
         type uint32 {
           range 0..16777215;
         }
       }
       typedef distinguished-name-type {
         type string;
       }
       typedef simple-address {
         type union {
           type inet:ip-address;
           type inet:ip-prefix;
           type yang:mac-address;
           type distinguished-name-type;
           type inet:as-number;
         }
       }
       typedef lisp-address-family-ref {
         type identityref {
           base lisp-address-family;
         }
       }
       typedef lcaf-ref {
         type identityref {
           base lcaf;
         }
       }
       grouping lisp-address {
         leaf address-type {
           type lisp-address-family-ref;
         }
         leaf virtual-network-id {
           type instance-id-type;
         }
         choice address {
           leaf no-address {
             when "../address-type = 'laddr:no-addr-afi'" {
             }
             type empty;
           }
           leaf ipv4 {
             when "../address-type = 'laddr:ipv4-afi'" {
             }
             type inet:ipv4-address;
           }
           leaf ipv4-prefix {
             when "../address-type = 'laddr:ipv4-prefix-afi'" {
             }
             type inet:ipv4-prefix;
           }
           leaf ipv6 {
             when "../address-type = 'laddr:ipv6-afi'" {
             }
             type inet:ipv6-address;
           }
           leaf ipv6-prefix {
             when "../address-type = 'laddr:ipv6-prefix-afi'" {
             }
             type inet:ipv6-prefix;
           }
           leaf mac {
             when "../address-type = 'laddr:mac-afi'" {
             }
             type yang:mac-address;
           }
           leaf distinguished-name {
             when "../address-type = 'laddr:distinguished-name-afi'" {
             }
             type distinguished-name-type;
           }
           leaf as-number {
             when "../address-type = 'laddr:as-number-afi'" {
             }
             type inet:as-number;
           }
           container null-address {
             when "../address-type = 'laddr:null-address-lcaf'" {
             }
             leaf address {
               type empty;
             }
           }
           container afi-list {
             when "../address-type = 'laddr:afi-list-lcaf'" {
             }
             leaf-list address-list {
               type simple-address;
             }
           }
           container instance-id {
             when "../address-type = 'laddr:instance-id-lcaf'" {
             }
             leaf iid {
               type instance-id-type;
             }
             leaf mask-length {
               type uint8;
             }
             leaf address {
               type simple-address;
             }
           }
           container as-number-lcaf {
             when "../address-type = 'laddr:as-number-lcaf'" {
             }
             leaf as {
               type inet:as-number;
             }
             leaf address {
               type simple-address;
             }
           }
           container application-data {
             when "../address-type = 'laddr:application-data-lcaf'" {
             }
             leaf address {
               type simple-address;
             }
             leaf protocol {
               type uint8;
             }
             leaf ip-tos {
               type int32;
             }
             leaf local-port-low {
               type inet:port-number;
             }
             leaf local-port-high {
               type inet:port-number;
             }
             leaf remote-port-low {
               type inet:port-number;
             }
             leaf remote-port-high {
               type inet:port-number;
             }
           }
           container geo-coordinates {
             when "../address-type = 'laddr:geo-coordinates-lcaf'" {
             }
             leaf latitude {
               type bits {
                 bit N {
                 }
               }
             }
             leaf latitude-degrees {
               type uint8 {
                 range "0 .. 90";
               }
             }
             leaf latitude-minutes {
               type uint8 {
                 range 0..59;
               }
             }
             leaf latitude-seconds {
               type uint8 {
                 range 0..59;
               }
             }
             leaf longitude {
               type bits {
                 bit E {
                 }
               }
             }
             leaf longitude-degrees {
               type uint16 {
                 range "0 .. 180";
               }
             }
             leaf longitude-minutes {
               type uint8 {
                 range 0..59;
               }
             }
             leaf longitude-seconds {
               type uint8 {
                 range 0..59;
               }
             }
             leaf altitude {
               type int32;
             }
             leaf address {
               type simple-address;
             }
           }
           container nat-traversal {
             when "../address-type = 'laddr:nat-traversal-lcaf'" {
             }
             leaf ms-udp-port {
               type uint16;
             }
             leaf etr-udp-port {
               type uint16;
             }
             leaf global-etr-rloc {
               type simple-address;
             }
             leaf ms-rloc {
               type simple-address;
             }
             leaf private-etr-rloc {
               type simple-address;
             }
             leaf-list rtr-rlocs {
               type simple-address;
             }
           }
           container explicit-locator-path {
             when "../address-type = 'laddr:explicit-locator-path-lcaf'" {
             }
             list hop {
               key hop-id;
               ordered-by user;
               leaf hop-id {
                 type string;
               }
               leaf address {
                 type simple-address;
               }
               leaf lrs-bits {
                 type bits {
                   bit lookup {
                   }
                   bit rloc-probe {
                   }
                   bit strict {
                   }
                 }
               }
             }
           }
           container source-dest-key {
             when "../address-type = 'laddr:source-dest-key-lcaf'" {
             }
             leaf source {
               type simple-address;
             }
             leaf dest {
               type simple-address;
             }
           }
           container key-value-address {
             when "../address-type = 'laddr:key-value-address-lcaf'" {
             }
             leaf key {
               type simple-address;
             }
             leaf value {
               type simple-address;
             }
           }
           container service-path {
             when "../address-type = 'laddr:service-path-lcaf'" {
             }
             leaf service-path-id {
               type service-path-id-type;
             }
             leaf service-index {
               type uint8;
             }
           }
         }
       }
     }