path: root/src/lib/yang/models/kea-dhcp6.yang

module kea-dhcp6 {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang::kea-dhcp6";
  prefix "kea-dhcp6";

  import ietf-inet-types {
    prefix inet;
  }
  import ietf-yang-types {
    prefix yang;
  }
  import kea-types {
    prefix kea;
  }
  import kea-dhcp-types {
    prefix dhcp;
  }
  import kea-logging {
    prefix logging;
  }


  organization "Internet Systems Consortium";
  contact "kea-dev@lists.isc.org";
  description "This model defines a YANG data model that can be
               used to configure and manage a Kea DHCPv6 server.";

  revision 2018-08-20 {
    description "Initial revision";
    reference "";
  }

  /*
  * Typedefs
  */
  typedef host-identifier-type {
    type enumeration {
      enum "duid";
      enum "hw-address";
      enum "flex-id";
    }
    description "Host identifier type.";
  }

  /*
  * Groupings
  */
  grouping preferred-lifetime {
    leaf preferred-lifetime {
      type uint32;
      units "seconds";
      description "Preferred lifetime.";
    }
  }

  grouping relay {
    leaf-list ip-addresses {
      type inet:ipv6-address;
      description "IPv6 addresses.";
    }
  }

  grouping rapid-commit {
    leaf rapid-commit {
      type boolean;
      default false;
    }
  }

  grouping subnet6-list {
    description "Subnet6 list.";
    list subnet6 {
      key id;
      ordered-by user;
      uses preferred-lifetime;
      uses dhcp:valid-lifetime;
      uses dhcp:renew-timer;
      uses dhcp:rebind-timer;
      uses option-data-list;
      container pools {
        list pool {
          key "start-address end-address";
          ordered-by user;
          leaf prefix {
            type inet:ipv6-prefix;
            description "Pool prefix.";
          }
          leaf start-address {
            type inet:ipv6-address;
            mandatory true;
            description "First IPv6 address in a pool.";
          }
          leaf end-address {
            type inet:ipv6-address;
            mandatory true;
            description "Last IPv6 address in a pool.";
          }
          uses option-data-list;
          uses dhcp:pool-client-class;
          uses dhcp:pool-require-client-classes;
          uses dhcp:pool-user-context;
        }
      }
      container pd-pools {
        list pd-pool {
          key prefix;
          ordered-by user;
          leaf prefix {
            type inet:ipv6-prefix;
            mandatory true;
            description "IPv6 pool prefix.";
          }
          leaf delegated-len {
            type uint8;
            description "Prefix pool delegated length.";
          }
          uses option-data-list;
          uses dhcp:client-class {
            refine client-class {
              description "Prefix pool client class guard. (only
                           clients belonging to this class will be
                           allowed in this pool).";
            }
          }
          uses dhcp:require-client-classes {
            refine require-client-classes {
              description "Prefix pool require client classes.";
            }
          }
          leaf excluded-prefix {
            type inet:ipv6-prefix;
            description "Prefix pool excluded prefix.";
          }
          uses kea:user-context {
            refine user-context {
              description "Prefix pool user context. Arbitrary JSON data
                           can be stored here.";
            }
          }
        }
      }
      leaf subnet {
        type inet:ipv6-prefix;
        mandatory true;
        description "IPv6 subnet prefix.";
      }
      uses dhcp:subnet-interface;
      uses dhcp:subnet-interface-id;
      uses dhcp:subnet-id;
      uses rapid-commit {
        refine rapid-commit {
          description "Subnet rapid commit flag.";
        }
      }
      uses dhcp:subnet-client-class;
      uses dhcp:require-client-classes;
      container reservations {
        description "A container with host reservations specific to
                     this IPv6 subnet.";
        list host {
          key "identifier-type identifier";
          leaf identifier-type {
            type host-identifier-type;
            mandatory true;
            description "Host identifier type.";
          }
          uses dhcp:host-identifier;
          leaf-list ip-addresses {
            type inet:ipv6-address;
            description "Host reserved IP addresses.";
          }
          leaf-list prefixes {
            type inet:ipv6-prefix;
            description "Host reserved IP prefixes.";
          }
          uses dhcp:host-hostname;
          uses dhcp:host-client-classes;
          uses option-data-list;
          uses dhcp:host-user-context;
        }
      }
      uses dhcp:subnet-reservation-mode;
      container relay {
        description "Optional information about relay agent.";
        uses relay;
      }
      uses dhcp:subnet-user-context;
    }
  }

  grouping client-class {
    uses dhcp:class-name;
    uses dhcp:class-test;
    uses dhcp:class-only-if-required;
    uses option-data-list;
    uses dhcp:class-user-context;
  }

  grouping option-def-list {
    container option-def-list {
      description "Option definition list.";
      list option-def {
        key "code space";
        leaf code {
          type uint16;
          mandatory true;
          description "Option code to be used by the new option definition.";
        }
        leaf space {
          type string;
          mandatory true;
          description "Option space for the new option (typically dhcp6).";
        }
        uses dhcp:option-def-name;
        uses dhcp:option-def-type;
        uses dhcp:option-def-record-types;
        uses dhcp:option-def-encapsulate;
        uses dhcp:option-def-array;
        uses dhcp:option-def-user-context;
      }
    }
  }

  grouping option-data-list {
    container option-data-list {
      description "Option data list.";
      list option-data {
        key "code space";
        leaf code {
          type uint16;
          mandatory true;
          description "Option code.";
        }
        leaf space {
          type string;
          mandatory true;
          description "Option space.";
        }
        uses dhcp:option-data-name;
        uses dhcp:option-data-data;
        uses dhcp:option-data-csv-format;
        uses dhcp:option-data-always-send;
        uses dhcp:option-data-user-context;
      }
    }
  }

  /*
  * Data Nodes
  */

  container config {
    description "Contains DHCPv6 server configuration.";
    config true;

    uses preferred-lifetime;
    uses dhcp:valid-lifetime;
    uses dhcp:renew-timer;
    uses dhcp:rebind-timer;
    uses dhcp:decline-probation-period;

    container subnet6 {
      description "Global subnet6 list.";
      uses subnet6-list;
    }

    container shared-networks {
      description "Defines a list of IPv6 shared networks.";
      list shared-network {
        key name;
        uses dhcp:network-name;
        container subnet6 {
          description "List of IPv6 subnets that belong to this shared
                       network.";
          uses subnet6-list;
        }
        uses dhcp:network-interface;
        uses dhcp:network-interface-id;
        uses dhcp:renew-timer;
        uses dhcp:rebind-timer;
        uses option-data-list;
        container relay {
          description "Optional information about relay agent.";
          uses relay;
        }
        uses dhcp:network-reservation-mode;
        uses dhcp:network-client-class;
        uses dhcp:require-client-classes;
        uses preferred-lifetime;
        uses rapid-commit {
          refine rapid-commit {
            description "Shared network rapid commit flag.";
          }
        }
        uses dhcp:valid-lifetime;
        uses dhcp:network-user-context;
      }
    }

    container interfaces-config {
      description "Network interfaces configuration.";
      leaf-list interfaces {
        type string;
        description "Name of the interface (e.g. eth0) or name/address
                     (e.g. eth0/2001:db8::1) or * (use all interfaces).";
      }
      uses dhcp:interfaces-re-detect;
      uses dhcp:interfaces-user-context;
    }

    uses dhcp:databases;

    leaf-list relay-supplied-options {
      type string;
      description "Relay supplied options.";
    }

    leaf-list mac-sources {
      type string;
      description "MAC address sources.";
    }

    leaf-list host-reservation-identifiers {
      type host-identifier-type;
      description "Host reservation identifier.";
    }

    container client-classes {
      description "Client classes.";
      list client-class {
        key name;
        ordered-by user;
        uses client-class;
      }
    }

    uses option-def-list;
    uses option-data-list;
    uses kea:hooks-libraries;
    uses dhcp:expired-leases-processing;

    container server-id {
      description "Server DUID.";
      leaf type {
        type enumeration {
          enum "LLT";
          enum "EN";
          enum "LL";
        }
        description "Server DIOD type.";
      }
      leaf identifier {
        type string;
        description "Server DUID identifier.";
      }
      leaf time {
        type uint32;
        description "Server DUID time.";
      }
      leaf htype {
        type uint16;
        description "Server DUID hardware type.";
      }
      leaf enterprise-id {
        type uint32;
        description "Server DUID enterprise ID.";
      }
      leaf persist {
        type boolean;
        default true;
        description "Server DUID persist flag.";
      }
      leaf user-context {
        type kea:user-context;
        description "Server DUID user context.";
      }
    }

    uses dhcp:dhcp4o6-port;
    uses dhcp:control-socket;
    uses dhcp:dhcp-ddns;
    uses kea:user-context {
      refine user-context {
        description "DHCPv6 server user context. Arbitrary JSON data can
                     be stored here.";
      }
    }
    uses dhcp:sanity-checks;
  }

  container logging {
    description "Logging";
    config true;

    uses logging:configuration;
  }

  /*
  * State data
  */
  container state {
    description "State of Kea DHCPv6 server.";
    config false;

    container leases {
      description "Kea DHCPv6 leases.";
      list lease {
        key ip-address;
        leaf ip-address {
          type inet:ipv6-address;
          mandatory true;
          description "Lease IP address.";
        }
        leaf duid {
          type binary;
          mandatory true;
          description "Lease DUID.";
        }
        uses dhcp:valid-lifetime {
          refine valid-lifetime {
            mandatory true;
          }
        }
        leaf cltt {
          type uint32;
          units "seconds";
          mandatory true;
          description "Lease client last transmission time.";
        }
        leaf subnet-id {
          type uint32;
          mandatory true;
          description "Lease subnet ID.";
        }
        leaf preferred-lifetime {
          type uint32;
          units "seconds";
          mandatory true;
          description "Lease preferred lifetime.";
        }
        leaf lease-type {
          type enumeration {
            enum "IA_NA";
            enum "IA_TA";
            enum "IA_PD";
          }
          mandatory true;
          description "Lease IA type.";
        }
        leaf iaid {
          type uint32;
          mandatory true;
          description "Lease IA ID.";
        }
        leaf prefix-length {
          type uint8 {
            range 0..128;
          }
          description "Lease prefix length.";
        }
        leaf fqdn-fwd {
          type boolean;
          default false;
          description "Lease FQDN forward flag.";
        }
        leaf fqdn-rev {
          type boolean;
          default false;
          description "Lease FQDN reverse lag.";
        }
        leaf hostname {
          type string;
          default "";
          description "Lease hostname.";
        }
        leaf state {
          type dhcp:lease-state;
          default "default";
          description "Lease state.";
        }
        leaf user-context {
          type kea:user-context;
          description "Lease user context.";
        }
        leaf hw-address {
          type string;
          description "Lease hardware address.";
        }
      }
    }

    container lease-stats {
      list subnet {
        key subnet-id;
        leaf subnet-id {
          type uint32;
          mandatory true;
          description "Subnet ID.";
        }
        leaf total-nas {
          type uint32;
          mandatory true;
          description "Total non-temporary addresses counter.";
        }
        leaf assigned-nas {
          type uint32;
          mandatory true;
          description "Assigned non-temporary counter.";
        }
        leaf declined-nas {
          type uint32;
          mandatory true;
          description "Declined non-temporary addresses counter.";
        }
        leaf total-pds {
          type uint32;
          mandatory true;
          description "Total delegated prefixes counter.";
        }
        leaf assigned-pds {
          type uint32;
          mandatory true;
          description "Assigned delegated prefixe counter.";
        }
      }
    }

    container hosts {
      description "Kea DHCPv6 hosts.";
      list host {
        key "subnet-id identifier-type identifier";
        leaf identifier-type {
          type host-identifier-type;
          mandatory true;
          description "Host identifier type.";
        }
        uses dhcp:host-identifier;
        uses dhcp:host-subnet-id;
        leaf-list ip-addresses {
          type inet:ipv6-address;
          description "Host reserved IP addresses.";
        }
        leaf-list prefixes {
          type inet:ipv6-prefix;
          description "Host reserved prefixes.";
        }
        uses dhcp:host-hostname;
        uses dhcp:host-client-classes;
        uses option-data-list;
        uses dhcp:host-user-context;
        leaf auth-key {
          type string;
          description "Host authentication key.";
        }
      }
    }
  }
}