[lispflowmapping.git] / mappingservice / yangmodel / src / main / yang / mappingservice.yang

  module lispflowmapping {

    

    namespace
      "lispflowmapping";

    prefix lispflowmapping;
    
    import ietf-inet-types {
               prefix inet;
               revision-date 2010-09-24;
       }
       
       import ietf-yang-types {
               prefix yang;
               revision-date 2010-09-24;
       }

    organization "LISP Flow Mapping";

    contact
      "David Goldberg <david.goldberg@contextream.com>
      Vina Ermagan <vermagan@cisco.com>";

    description
      "YANG version of the mapping service.";

    revision "2013-10-31" {
      description
        "mapping service";
    }
    
    grouping TransportAddress{
        container TransportAddress {            
            leaf ipAddress {    
                type inet:ip-address;   
                reference "http://www.iana.org/assignments/safi-namespace/safi-namespace.xhtml";                
            }   
             leaf port {        
                        type inet:port-number;  
                }       
        }
    }

    grouping LispAFIAddress {
        leaf afi {
               type int16;
               reference "http://www.iana.org/assignments/safi-namespace/safi-namespace.xhtml";
       }
    }
    
    grouping LispNoAddress {
        uses LispAFIAddress {
                refine afi {
                default 0;
                }
        }
    }
    
    grouping LispIpv4Address {
        uses LispAFIAddress {
                refine afi {
                default 1;
                }
        }
        leaf Ipv4Address {
               type inet:ipv4-address;
               reference "https://tools.ietf.org/html/rfc3209#section-4.6.2.1";
        }
    }
    
    grouping LispIpv6Address {
        uses LispAFIAddress{
                refine afi {
                default 2;
                }
        }
        leaf Ipv6Address {
                type inet:ipv6-address;
        }
    }
    
    grouping LispMacAddress {
        uses LispAFIAddress{
                refine afi {
                default 16389;
                }
        }
        leaf MacAddress {
                type yang:mac-address;
        }
    }
    
    grouping LispDistinguishedNameAddress {
        uses LispAFIAddress{
                refine afi {
                default 17;
        }
    }
        leaf distinguishedName {
              type string;
       }
    }
    
    
    grouping LispASAddress {
        uses LispAFIAddress{
                refine afi {
                default 18;
        }
    }
        leaf AS {
              type int32;
       }
    }
    
    grouping LispSimpleAddress {
       choice primitiveAddress {
                case No {
                        uses LispNoAddress;
                }
                case Ipv4 {
                        uses LispIpv4Address;
                }
                case Ipv6 {
                        uses LispIpv6Address;
                }
                case Mac {
                        uses LispMacAddress;
                }
                case DistinguishedName {
                                uses LispDistinguishedNameAddress;
                }
                case AS {
                                uses LispASAddress;
                }
        }
    }
    
    grouping ReencapHop {
        container hop {
               uses LispSimpleAddress;
       }
       leaf lookup {
             type boolean;
       }
       leaf RLOCProbe {
             type boolean;
       }
       leaf strict {
             type boolean;
       }
    }
    
    
    
    
    grouping LispLcafAddress {
        uses LispAFIAddress{
                refine afi {
                        default 16387;
                }
        }
       leaf lcafType {
               type uint8;
               reference "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-03";
       }
    }
    
    grouping LcafSegmentAddress {
        reference http://tools.ietf.org/html/draft-ietf-lisp-lcaf-03#section-4.1;
        uses LispLcafAddress{
                refine lcafType {
                        default 2;
        }
    }
        leaf instanceId {
               type uint32{
                        range "0 .. 16777215";
               }
       }
       container Address {
               uses LispSimpleAddress;
       }
    }
    grouping LcafTrafficEngineeringAddress {
        reference http://tools.ietf.org/html/draft-ietf-lisp-lcaf-03#section-4.1;
        uses LispLcafAddress{
                refine lcafType {
                        default 10;
        }
    }
       list Hops {
               uses ReencapHop;
       }
    }
    
    grouping LcafListAddress {
        reference http://tools.ietf.org/html/draft-ietf-lisp-lcaf-03#section-4.1;
        uses LispLcafAddress{
                refine lcafType {
                        default 1;
        }
    }
       list Addresses {
               uses LispSimpleAddress;
       }
    }
    
       grouping LcafSourceDestAddress {
                reference "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-03#section-4.11";
                uses LispLcafAddress{
                        refine lcafType {
                                default 12;
                        }
                }
            container srcAddress {
                uses LispSimpleAddress;
             }
             container dstAddress {
                uses LispSimpleAddress;
             }
             leaf srcMaskLength {
                type uint8;
             }
             leaf dstMaskLength {
                 type uint8;
              }
        }
        
        grouping LcafKeyValueAddress {
                reference "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-04#section-4.14";
                uses LispLcafAddress{
                        refine lcafType {
                                default 15;
                        }
                }
            container key {
                uses LispSimpleAddress;
             }
             container value {
                uses LispSimpleAddress;
             }
        }
        
        grouping LcafApplicationDataAddress {
                reference "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-03#section-4.11";
                uses LispLcafAddress{
                        refine lcafType {
                                default 4;
                        }
                }
            container Address {
                uses LispSimpleAddress;
             }
             leaf protocol {
                type uint8;
             }
             leaf ipTos {
                 type int32;
              }
              leaf localPort {  
                                type inet:port-number;  
                        }       
                        leaf remotePort {       
                                type inet:port-number;  
                        }       
        }

       
       grouping LispAddress {
       container LispAddressContainer{
               choice Address {
                                case No {
                                                uses LispNoAddress;
                                        }
                       case Ipv4 {
                                                uses LispIpv4Address;
                                        }
                                        case Ipv6 {
                                                uses LispIpv6Address;
                                        }
                                        case Mac {
                                                uses LispMacAddress;
                                        }
                                        case DistinguishedName {
                                                        uses LispDistinguishedNameAddress;
                                        }
                                        case AS {
                                                        uses LispASAddress;
                                        }
                       case LcafSegment {
                               uses LcafSegmentAddress;
                       }
                       case LcafSourceDest {
                               uses LcafSourceDestAddress;
                       }
                       case LcafKeyValue {
                               uses LcafKeyValueAddress;
                       }
                       case LcafList {
                               uses LcafListAddress;
                       }
                       case LcafApplicationData {
                               uses LcafApplicationDataAddress;
                       }
                       case LcafTrafficEngineering {
                               uses LcafTrafficEngineeringAddress;
                       }
               } 
       }
       }
    
    
    grouping EidRecords {
    list EidRecord {
        
                // EID
                uses LispAddress; 
                
                leaf mask {
                        type uint8;
                }
        }
    }
    
    grouping LocatorRecords {
    list LocatorRecord {
        leaf priority {
                type uint8;
        }
        leaf weight {
                type uint8;
        }
        leaf multicastPriority {
                type uint8;
        }
        leaf multicastWeight {
                type uint8;
        }
        leaf localLocator {
                type boolean;
        }
        leaf rlocProbed {
                type boolean;
        }
        leaf routed {
                type boolean;
        }
        
        //locator address
        uses LispAddress; 
    }   
    }
    
    grouping EidToLocatorRecord {       
        leaf recordTtl {
                type int32;
        }
        leaf maskLength {
                type uint8;
        }
        leaf mapVersion {
                type int16;
        }
        leaf action {
                type enumeration {
                        enum NoAction;
                        enum NativelyForward;
                        enum SendMapRequest;
                        enum Drop;
                }
        }
        leaf authoritative {
                type boolean;
        }
        // EID prefix
        uses LispAddress; 
        
        // locator record list
        uses LocatorRecords;
    }
    
    grouping EidToLocatorRecords {
        list eidToLocatorRecord {
                uses EidToLocatorRecord;
        }
    }
    
    grouping xtrSiteId {
        leaf xtrId {
            type binary;
        }
        leaf siteId {
            type binary;
        }
    }

    grouping MapRegister {
        reference "http://tools.ietf.org/html/rfc6830#section-6.1.6";
        reference "http://tools.ietf.org/html/draft-ermagan-lisp-nat-traversal-05#section-4.3";
        leaf proxyMapReply {
                type boolean;
        }
        leaf xtrSiteIdPresent {
            type boolean;
        }
        leaf wantMapNotify {
                type boolean;
        }
        leaf nonce {
                type int64;
        }
        leaf keyId {
                type int16;
        }
        leaf authenticationData {
                type binary;
        }
        uses EidToLocatorRecords;
        uses xtrSiteId;
    }
    
    grouping MapNotify {
        reference "http://tools.ietf.org/html/rfc6830#section-6.1.7";
        reference "http://tools.ietf.org/html/draft-ermagan-lisp-nat-traversal-05#section-4.3";
        leaf xtrSiteIdPresent {
            type boolean;
        }
        leaf nonce {
                type int64;
        }
        leaf keyId {
                type int16;
        }
        leaf authenticationData {
                type binary;
        }
        uses EidToLocatorRecords;
        uses xtrSiteId;
    }
    
    grouping MapRequest {
        reference "http://tools.ietf.org/html/rfc6830#section-6.1.2";
        leaf authoritative {
                type boolean;
        }
        leaf mapDataPresent {
                type boolean;
        }
        leaf probe {
                type boolean;
        }
        leaf smr {
                type boolean;
        }
        leaf pitr {
                type boolean;
        }
        leaf smrInvoked {
                type boolean;
        }
        leaf nonce {
                type int64;
        }
        container SourceEid {
                uses LispAddress; 
        }
        list itrRloc {
                uses LispAddress; 
        }
        uses EidRecords;
        container MapReply{ 
                uses EidToLocatorRecord;
        }
    }
    
    grouping MapReply {
        reference "http://tools.ietf.org/html/rfc6830#section-6.1.4";
        leaf probe {
                type boolean;
        }
        leaf nonce {
                type int64;
        }
        leaf echoNonceEnabled {
                type boolean;
        }
        leaf securityEnabled {
                type boolean;
        }
        uses EidToLocatorRecords;
    }
    
    grouping MapRegisterNotification {
        container MapRegister {
                uses MapRegister;
        }
        uses TransportAddress;
        
    }
    
    grouping MapNotifyMessage {
        container MapNotify {
                uses MapNotify;
        }
        uses TransportAddress;
        
    }
    
    grouping MapRequestMessage {
        container MapRequest {
                uses MapRequest;
        }
        uses TransportAddress;
        
    }
    
    grouping MapRequestNotification {
        container MapRequest {
                uses MapRequest;
        }
        uses TransportAddress;
    
    }
    
    
    grouping MapReplyMessage {
        container MapReply {
                uses MapReply;
        }
        uses TransportAddress;
        
    }
    
    rpc sendMapNotify {
        input {
                uses MapNotifyMessage;
        }
    }
    
    rpc sendMapRequest {
        input {
                uses MapRequestMessage;
        }
    }
    
    rpc sendMapReply {
        input {
                uses MapReplyMessage;
        }
    }
    
    notification addMapping {
        uses MapRegisterNotification;
    }
    
    notification requestMapping {
        uses MapRequestNotification;
    }
    
    notification xtrRequestMapping {
        uses MapRequestNotification;
    }
    
}