module ietf-diffserv-classifier {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-diffserv-classifier";

    prefix classifier;

    import ietf-inet-types {
      prefix inet;
    }

    organization
      "IETF NETMOD (Netmod Working Group) Working Group";

    contact
      "WG Web:   <http://tools.ietf.org/wg/netmod/>
     WG List:  <mailto:netmod@ietf.org>
     
     WG Chair: Juergen Schoenwaelder
               <mailto:j.schoenwaelder@jacobs-university.de>
     
     WG Chair: Tom Nadeau
               <mailto:tnadeau@lucidvision.com>
     
     Editor:   Aseem Choudhary
               <mailto:asechoud@cisco.com>
     
     Editor:   Shitanshu Shah
               <mailto:svshah@cisco.com>";

    description
      "This module contains a collection of YANG definitions for
     configuring diffserv specification implementations.
     
     Copyright (c) 2014 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
     (http://trustee.ietf.org/license-info).
     
     This version of this YANG module is part of RFC XXXX; see
     the RFC itself for full legal notices.";

    revision "2015-04-07" {
      description
        "Latest revision of diffserv based classifier";
      reference
        "RFC XXXX";

    }


    feature policy-inline-classifier-config {
      description
        " This feature allows classifier configuration 
        directly under policy.";
    }

    identity filter-type {
      description
        " This is identity of base filter-type";
    }

    identity dscp {
      base filter-type;
      description "DSCP filter-type";
    }

    identity source-ip-address {
      base filter-type;
      description
        "source-ip-address filter-type";
    }

    identity destination-ip-address {
      base filter-type;
      description
        "destination-ip-address filter-type";
    }

    identity source-port {
      base filter-type;
      description "source-port filter-type";
    }

    identity destination-port {
      base filter-type;
      description
        "destination-port filter-type";
    }

    identity protocol {
      base filter-type;
      description "protocol filter-type";
    }

    identity classifier-entry-filter-operation-type {
      description
        "Classifier entry filter logical operation";
    }

    identity match-any-filter {
      base classifier-entry-filter-operation-type;
      description
        "Classifier entry filter logical OR operation";
    }

    identity match-all-filter {
      base classifier-entry-filter-operation-type;
      description
        "Classifier entry filter logical AND operation";
    }

    grouping filters {
      description
        "Filters in a Classifier entry";
      leaf filter-type {
        type identityref {
          base filter-type;
        }
        description
          "This leaf defines type of the filter";
      }

      leaf filter-logical-not {
        type boolean;
        description
          "
         This is logical-not operator for a filter. When true, it 
         indicates filter looks for absence of a pattern defined 
         by the filter
        ";
      }

      choice filter-param {
        description "Choice of filter types";
        case dscp {
          description
            "Filter containing list of dscp ranges";
          list dscp-cfg {
            key "dscp-min dscp-max";
            description
              "list of dscp ranges";
            leaf dscp-min {
              type inet:dscp;
              description
                "Minimum value of dscp range";
            }

            leaf dscp-max {
              type inet:dscp;
              description
                "maximum value of dscp range";
            }
          }  // list dscp-cfg
        }  // case dscp

        case source-ip-address {
          description
            "Filter containing list of source ip addresses";
          list source-ip-address-cfg {
            key "source-ip-addr";
            description
              "list of source ip address";
            leaf source-ip-addr {
              type inet:ip-prefix;
              description "source ip prefix";
            }
          }  // list source-ip-address-cfg
        }  // case source-ip-address

        case destination-ip-address {
          description
            "Filter containing list of destination ip address";
          list destination-ip-address-cfg {
            key "destination-ip-addr";
            description
              "list of destination ip address";
            leaf destination-ip-addr {
              type inet:ip-prefix;
              description
                "destination ip prefix";
            }
          }  // list destination-ip-address-cfg
        }  // case destination-ip-address

        case source-port {
          description
            "Filter containing list of source-port ranges";
          list source-port-cfg {
            key "source-port-min source-port-max";
            description
              "list of ranges of source port";
            leaf source-port-min {
              type inet:port-number;
              description
                "minimum value of source port range";
            }

            leaf source-port-max {
              type inet:port-number;
              description
                "maximum value of source port range";
            }
          }  // list source-port-cfg
        }  // case source-port

        case destination-port {
          description
            "Filter containing list of destination-port ranges";
          list destination-port-cfg {
            key "destination-port-min destination-port-max";
            description
              "list of ranges of destination port";
            leaf destination-port-min {
              type inet:port-number;
              description
                "minimum value of destination port range";
            }

            leaf destination-port-max {
              type inet:port-number;
              description
                "maximum value of destination port range";
            }
          }  // list destination-port-cfg
        }  // case destination-port

        case protocol {
          description "Filter Type Protocol";
          list protocol-cfg {
            key "protocol-min protocol-max";
            description
              "list of ranges of protocol values";
            leaf protocol-min {
              type uint8 {
                range "0..255";
              }
              description
                "minimum value of protocol range";
            }

            leaf protocol-max {
              type uint8 {
                range "0..255";
              }
              description
                "maximum value of protocol range";
            }
          }  // list protocol-cfg
        }  // case protocol
      }  // choice filter-param
    }  // grouping filters

    grouping classifier-entry-generic-attr {
      description "Classifier attributes";
      leaf classifier-entry-name {
        type string;
        description
          "Diffserv classifier name";
      }

      leaf classifier-entry-descr {
        type string;
        description
          "Description of the class template";
      }

      leaf classifier-entry-filter-operation {
        type identityref {
          base classifier-entry-filter-operation-type;
        }
        default "match-any-filter";
        description
          "Filters are applicable as any or all filters";
      }
    }  // grouping classifier-entry-generic-attr

    grouping classifier-entry-inline-attr {
      description
        "Classifier inline attributes";
      leaf classifier-entry-inline {
        type boolean;
        default "false";
        description
          "Indication of inline classifier entry";
      }

      leaf classifier-entry-filter-oper {
        type identityref {
          base classifier-entry-filter-operation-type;
        }
        default "match-any-filter";
        description
          "Filters are applicable as any or all filters";
      }

      list filter-entry {
        if-feature policy-inline-classifier-config;
        must
          "../classifier-entry-inline = 'true'" {
          description
            "For inline filter configuration, inline attribute
           must be true";
        }
        key "filter-type filter-logical-not";
        description
          "Filters configured inline in a policy";
        uses filters;
      }  // list filter-entry
    }  // grouping classifier-entry-inline-attr

    container classifiers {
      description "list of classifier entry";
      list classifier-entry {
        key "classifier-entry-name";
        description
          "classifier entry template";
        uses classifier-entry-generic-attr;

        list filter-entry {
          key "filter-type filter-logical-not";
          description "Filter configuration";
          uses filters;
        }  // list filter-entry
      }  // list classifier-entry
    }  // container classifiers
  }  // module ietf-diffserv-classifier