From 10d169e7883d78a61a2db923559c79f4621fc886 Mon Sep 17 00:00:00 2001 From: Andrej Kozemcak Date: Tue, 15 Jan 2019 15:46:31 +0100 Subject: Add ietf NAT yang module Change-Id: I28e1ce057e9e778529e9be2f526cf8040afd8e61 Signed-off-by: Andrej Kozemcak --- src/plugins/yang/ietf/ietf-nat@2017-11-16.yang | 2368 ++++++++++++++++++++++++ 1 file changed, 2368 insertions(+) create mode 100644 src/plugins/yang/ietf/ietf-nat@2017-11-16.yang diff --git a/src/plugins/yang/ietf/ietf-nat@2017-11-16.yang b/src/plugins/yang/ietf/ietf-nat@2017-11-16.yang new file mode 100644 index 0000000..bb7e3a1 --- /dev/null +++ b/src/plugins/yang/ietf/ietf-nat@2017-11-16.yang @@ -0,0 +1,2368 @@ +module ietf-nat { + + yang-version 1.1; + + namespace + "urn:ietf:params:xml:ns:yang:ietf-nat"; + + prefix nat; + + import ietf-inet-types { + prefix inet; + } + import ietf-yang-types { + prefix yang; + } + import ietf-interfaces { + prefix if; + } + + organization + "IETF OPSAWG (Operations and Management Area Working Group)"; + + contact + "WG Web: + WG List: + + Editor: Mohamed Boucadair + + + Editor: Senthil Sivakumar + + + Editor: Christian Jacquenet + + + Editor: Suresh Vinapamula + + + Editor: Qin Wu + "; + + description + "This module is a YANG module for NAT implementations. + + NAT44, Network Address and Protocol Translation from IPv6 + Clients to IPv4 Servers (NAT64), Customer-side transLATor (CLAT), + Stateless IP/ICMP Translation (SIIT), Explicit Address Mappings + for Stateless IP/ICMP Translation (SIIT EAM), and IPv6 Network + Prefix Translation (NPTv6) are covered. + + Copyright (c) 2017 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 "2017-11-16" { + description "Initial revision."; + reference + "RFC XXXX: A YANG Data Model for Network Address Translation + (NAT) and Network Prefix Translation (NPT)"; + + } + + + typedef percent { + type uint8 { + range "0 .. 100"; + } + description "Percentage"; + } + + feature basic-nat44 { + description + "Basic NAT44 translation is limited to IP addresses alone."; + reference + "RFC 3022: Traditional IP Network Address Translator + (Traditional NAT)"; + + } + + feature napt44 { + description + "Network Address/Port Translator (NAPT): translation is + extended to include IP addresses and transport identifiers + (such as a TCP/UDP port or ICMP query ID). + + If the internal IP address is not sufficient to uniquely + disambiguate NAPT44 mappings, an additional attribute is + required. For example, that additional attribute may + be an IPv6 address (a.k.a., DS-Lite (RFC 6333)) or + a Layer 2 identifier (a.k.a., Per-Interface NAT + (RFC 6619))"; + reference + "RFC 3022: Traditional IP Network Address Translator + (Traditional NAT)"; + + } + + feature dst-nat { + description + "Destination NAT is a translation that acts on the destination + IP address and/or destination port number. This flavor is + usually deployed in load balancers or at devices + in front of public servers."; + } + + feature nat64 { + description + "NAT64 translation allows IPv6-only clients to contact IPv4 + servers using unicast UDP, TCP, or ICMP. One or more + public IPv4 addresses assigned to a NAT64 translator are + shared among several IPv6-only clients."; + reference + "RFC 6146: Stateful NAT64: Network Address and Protocol + Translation from IPv6 Clients to IPv4 Servers"; + + } + + feature siit { + description + "The Stateless IP/ICMP Translation Algorithm (SIIT), which + translates between IPv4 and IPv6 packet headers (including + ICMP headers). + + In the stateless mode, an IP/ICMP translator converts IPv4 + addresses to IPv6 and vice versa solely based on the + configuration of the stateless IP/ICMP translator and + information contained within the packet being translated. + + The translator must support the stateless address mapping + algorithm defined in RFC6052, which is the default behavior."; + reference + "RFC 7915: IP/ICMP Translation Algorithm"; + + } + + feature clat { + description + "CLAT is customer-side translator that algorithmically + translates 1:1 private IPv4 addresses to global IPv6 addresses, + and vice versa. + + When a dedicated /64 prefix is not available for translation + from DHCPv6-PD, the CLAT may perform NAT44 for all IPv4 LAN + packets so that all the LAN-originated IPv4 packets appear + from a single IPv4 address and are then statelessly translated + to one interface IPv6 address that is claimed by the CLAT via + the Neighbor Discovery Protocol (NDP) and defended with + Duplicate Address Detection."; + reference + "RFC 6877: 464XLAT: Combination of Stateful and Stateless + Translation"; + + } + + feature eam { + description + "Explicit Address Mapping (EAM) is a bidirectional coupling + between an IPv4 Prefix and an IPv6 Prefix."; + reference + "RFC 7757: Explicit Address Mappings for Stateless IP/ICMP + Translation"; + + } + + feature nptv6 { + description + "NPTv6 is a stateless transport-agnostic IPv6-to-IPv6 + prefix translation."; + reference + "RFC 6296: IPv6-to-IPv6 Network Prefix Translation"; + + } + + identity nat-type { +// base + description + "Base identity for nat type."; + } + + identity basic-nat44 { + base nat:nat-type; + description + "Identity for Basic NAT support."; + reference + "RFC 3022: Traditional IP Network Address Translator + (Traditional NAT)"; + + } + + identity napt44 { + base nat:nat-type; + description + "Identity for NAPT support."; + reference + "RFC 3022: Traditional IP Network Address Translator + (Traditional NAT)"; + + } + + identity dst-nat { + base nat:nat-type; + description + "Identity for Destination NAT support."; + } + + identity nat64 { + base nat:nat-type; + description + "Identity for NAT64 support."; + reference + "RFC 6146: Stateful NAT64: Network Address and Protocol + Translation from IPv6 Clients to IPv4 Servers"; + + } + + identity siit { + base nat:nat-type; + description + "Identity for SIIT support."; + reference + "RFC 7915: IP/ICMP Translation Algorithm"; + + } + + identity clat { + base nat:nat-type; + description + "Identity for CLAT support."; + reference + "RFC 6877: 464XLAT: Combination of Stateful and Stateless + Translation"; + + } + + identity eam { + base nat:nat-type; + description + "Identity for EAM support."; + reference + "RFC 7757: Explicit Address Mappings for Stateless IP/ICMP + Translation"; + + } + + identity nptv6 { + base nat:nat-type; + description + "Identity for NPTv6 support."; + reference + "RFC 6296: IPv6-to-IPv6 Network Prefix Translation"; + + } + + grouping port-number { + description + "Individual port or a range of ports. + When only start-port-number is present, + it represents a single port."; + leaf start-port-number { + type inet:port-number; + description + "Begining of the port range."; + reference + "Section 3.2.9 of RFC 8045."; + + } + + leaf end-port-number { + type inet:port-number; + must ". >= ../start-port-number" { + error-message + "The end-port-number must be greater than or + equal to start-port-number."; + } + description "End of the port range."; + reference + "Section 3.2.10 of RFC 8045."; + + } + } // grouping port-number + + grouping port-set { + description + "Indicates a set of ports. + + It may be a simple port range, or use the Port Set ID (PSID) + algorithm to represent a range of transport layer + ports which will be used by a NAPT."; + choice port-type { + default 'port-range'; + description + "Port type: port-range or port-set-algo."; + reference + "Section 7597: Mapping of Address and Port with + Encapsulation (MAP-E)"; + + case port-range { + uses port-number; + } // case port-range + + case port-set-algo { + leaf psid-offset { + type uint8 { + range "0..15"; + } + description + "The number of offset bits (a.k.a., 'a' bits). + Specifies the numeric value for the excluded port + range/offset bits. + + Allowed values are between 0 and 15 "; + reference + "Section 5.1 of RFC 7597"; + + } + + leaf psid-len { + type uint8 { + range "0..15"; + } + mandatory true; + description + "The length of PSID, representing the sharing + ratio for an IPv4 address. + + (also known as 'k'). + + The address-sharing ratio would be 2^k."; + reference + "Section 5.1 of RFC 7597"; + + } + + leaf psid { + type uint16; + mandatory true; + description + "Port Set Identifier (PSID) value, which + identifies a set of ports algorithmically."; + reference + "Section 5.1 of RFC 7597"; + + } + } // case port-set-algo + } // choice port-type + } // grouping port-set + + grouping mapping-entry { + description + "NAT mapping entry. + + If an attribute is not stored in the mapping/session table, + this means the corresponding fields of a packet that + matches this entry is not rewritten by the NAT or this + information is not required for NAT filtering purposes."; + leaf index { + type uint32; + description + "A unique identifier of a mapping entry. This identifier can be + automatically assigned by the NAT instance or be explicitly + configured."; + } + + leaf type { + type enumeration { + enum "static" { + value 0; + description + "The mapping entry is explicitly configured + (e.g., via command-line interface)."; + } + enum "dynamic-implicit" { + value 1; + description + "This mapping is created implicitly as a side effect + of processing a packet that requires a new mapping."; + } + enum "dynamic-explicit" { + value 2; + description + "This mapping is created as a result of an explicit + request, e.g., a PCP message."; + } + } + description + "Indicates the type of a mapping entry. E.g., + a mapping can be: static, implicit dynamic + or explicit dynamic."; + } + + leaf transport-protocol { + type uint8; + description + "Upper-layer protocol associated with this mapping. + Values are taken from the IANA protocol registry. + For example, this field contains 6 (TCP) for a TCP + mapping or 17 (UDP) for a UDP mapping. + + If this leaf is not instantiated, then the mapping + applies to any protocol."; + } + + leaf internal-src-address { + type inet:ip-prefix; + description + "Corresponds to the source IPv4/IPv6 address/prefix + of the packet received on an internal + interface."; + } + + container internal-src-port { + description + "Corresponds to the source port of the packet received + on an internal interface. + + It is used also to indicate the internal source ICMP + identifier. + + As a reminder, all the ICMP Query messages contain + an 'Identifier' field, which is referred to in this + document as the 'ICMP Identifier'."; + uses port-number; + } // container internal-src-port + + leaf external-src-address { + type inet:ip-prefix; + description + "Source IP address/prefix of the packet sent on an + external interface of the NAT."; + } + + container external-src-port { + description + "Source port of the packet sent on an external + interface of the NAT. + + It is used also to indicate the external source ICMP + identifier."; + uses port-number; + } // container external-src-port + + leaf internal-dst-address { + type inet:ip-prefix; + description + "Corresponds to the destination IP address/prefix + of the packet received on an internal interface + of the NAT. + + For example, some NAT implementations support + the translation of both source and destination + addresses and ports, sometimes referred to + as 'Twice NAT'."; + } + + container internal-dst-port { + description + "Corresponds to the destination port of the + IP packet received on the internal interface. + + It is used also to include the internal + destination ICMP identifier."; + uses port-number; + } // container internal-dst-port + + leaf external-dst-address { + type inet:ip-prefix; + description + "Corresponds to the destination IP address/prefix + of the packet sent on an external interface + of the NAT."; + } + + container external-dst-port { + description + "Corresponds to the destination port number of + the packet sent on the external interface + of the NAT. + + It is used also to include the external + destination ICMP identifier."; + uses port-number; + } // container external-dst-port + + leaf lifetime { + type uint32; + units "seconds"; + description + "When specified, it is used to track the connection that is + fully-formed (e.g., once the three-way handshake + TCP is completed) or the duration for maintaining + an explicit mapping alive. The mapping entry will be + removed by the NAT instance once this lifetime is expired. + + When reported in a get operation, the lifetime indicates + the remaining validity lifetime. + + Static mappings may not be associated with a + lifetime. If no lifetime is associated with a + static mapping, an explicit action is required to + remove that mapping."; + } + } // grouping mapping-entry + + container nat { + description "NAT module"; + container instances { + description "NAT instances"; + list instance { + key "id"; + description + "A NAT instance. This identifier can be automatically assigned + or explicitly configured."; + leaf id { + type uint32; + must ". >= 1"; + description + "NAT instance identifier. + + The identifier must be greater than zero as per RFC 7659."; + reference + "RFC 7659: Definitions of Managed Objects for Network + Address Translators (NATs)"; + + } + + leaf name { + type string; + description + "A name associated with the NAT instance."; + reference + "RFC 7659: Definitions of Managed Objects for Network + Address Translators (NATs)"; + + } + + leaf enable { + type boolean; + description + "Status of the NAT instance."; + } + + container capabilities { + config false; + description "NAT capabilities"; + leaf-list nat-flavor { + type identityref { + base nat-type; + } + description + "Supported translation type(s)."; + } + + leaf-list per-interface-binding { + type enumeration { + enum "unsupported" { + value 0; + description + "No capability to associate a NAT binding with + an extra identifier."; + } + enum "layer-2" { + value 1; + description + "The NAT instance is able to associate a mapping with + a layer-2 identifier."; + } + enum "dslite" { + value 2; + description + "The NAT instance is able to associate a mapping with + an IPv6 address (a.k.a., DS-Lite)."; + } + } + description + "Indicates the capability of a NAT to associate a particular + NAT session not only with the five tuples used for the + transport connection on both sides of the NAT but also with + the internal interface on which the user device is + connected to the NAT."; + reference + "Section 4 of RFC 6619"; + + } + + list transport-protocols { + key "protocol-id"; + description + "List of supported protocols."; + leaf protocol-id { + type uint8; + mandatory true; + description + "Upper-layer protocol associated with this mapping. + + Values are taken from the IANA protocol registry: + https://www.iana.org/assignments/protocol-numbers/ + protocol-numbers.xhtml + + For example, this field contains 6 (TCP) for a TCP + mapping or 17 (UDP) for a UDP mapping."; + } + + leaf protocol-name { + type string; + description + "The name of the Upper-layer protocol associated + with this mapping. + + Values are taken from the IANA protocol registry: + https://www.iana.org/assignments/protocol-numbers/ + protocol-numbers.xhtml + + For example, TCP, UDP, DCCP, and SCTP."; + } + } // list transport-protocols + + leaf restricted-port-support { + type boolean; + description + "Indicates source port NAT restriction support."; + reference + "RFC 7596: Lightweight 4over6: An Extension to + the Dual-Stack Lite Architecture."; + + } + + leaf static-mapping-support { + type boolean; + description + "Indicates whether static mappings are supported."; + } + + leaf port-randomization-support { + type boolean; + description + "Indicates whether port randomization is supported."; + reference + "Section 4.2.1 of RFC 4787."; + + } + + leaf port-range-allocation-support { + type boolean; + description + "Indicates whether port range allocation is supported."; + reference + "Section 1.1 of RFC 7753."; + + } + + leaf port-preservation-suport { + type boolean; + description + "Indicates whether port preservation is supported."; + reference + "Section 4.2.1 of RFC 4787."; + + } + + leaf port-parity-preservation-support { + type boolean; + description + "Indicates whether port parity preservation is + supported."; + reference + "Section 8 of RFC 7857."; + + } + + leaf address-roundrobin-support { + type boolean; + description + "Indicates whether address allocation round robin is + supported."; + } + + leaf paired-address-pooling-support { + type boolean; + description + "Indicates whether paired-address-pooling is + supported"; + reference + "REQ-2 of RFC 4787."; + + } + + leaf endpoint-independent-mapping-support { + type boolean; + description + "Indicates whether endpoint-independent- + mapping in Section 4 of RFC 4787 is + supported."; + reference + "Section 4 of RFC 4787."; + + } + + leaf address-dependent-mapping-support { + type boolean; + description + "Indicates whether address-dependent-mapping is + supported."; + reference + "Section 4 of RFC 4787."; + + } + + leaf address-and-port-dependent-mapping-support { + type boolean; + description + "Indicates whether address-and-port-dependent-mapping is + supported."; + reference + "Section 4 of RFC 4787."; + + } + + leaf endpoint-independent-filtering-support { + type boolean; + description + "Indicates whether endpoint-independent-filtering is + supported."; + reference + "Section 5 of RFC 4787."; + + } + + leaf address-dependent-filtering { + type boolean; + description + "Indicates whether address-dependent-filtering is + supported."; + reference + "Section 5 of RFC 4787."; + + } + + leaf address-and-port-dependent-filtering { + type boolean; + description + "Indicates whether address-and-port-dependent is + supported."; + reference + "Section 5 of RFC 4787."; + + } + + leaf fragment-behavior { + type enumeration { + enum "unsupported" { + value 0; + description + "No capability to translate incoming fragments. + All received fragments are dropped."; + } + enum "in-order" { + value 1; + description + "The NAT instance is able to translate fragments only if + they are received in order. That is, in particular the + header is in the first packet. Fragments received + out of order are dropped. "; + } + enum "out-of-order" { + value 2; + description + "The NAT instance is able to translate a fragment even + if it is received out of order. + + This behavior is the one recommended in RFC4787."; + reference + "REQ-14 of RFC 4787"; + + } + } + description + "The fragment behavior is the NAT instance's capability to + translate fragments received on the external interface of + the NAT."; + } + } // container capabilities + + leaf type { + type identityref { + base nat-type; + } + description + "Specify the translation type. Particularly useful when + multiple translation flavors are supported. + + If one type is supported by a NAT, this parameter is by + default set to that type."; + } + + leaf per-interface-binding { + type enumeration { + enum "disabled" { + value 0; + description + "Disable the capability to associate an extra identifier + with NAT mappings."; + } + enum "layer-2" { + value 1; + description + "The NAT instance is able to associate a mapping with + a layer-2 identifier."; + } + enum "dslite" { + value 2; + description + "The NAT instance is able to associate a mapping with + an IPv6 address (a.k.a., DS-Lite)."; + } + } + description + "A NAT that associates a particular NAT session not only with + the five tuples used for the transport connection on both + sides of the NAT but also with the internal interface on + which the user device is connected to the NAT. + + If supported, this mode of operation should be configurable, + and it should be disabled by default in general-purpose NAT + devices. + + If one single per-interface binding behavior is supported by + a NAT, this parameter is by default set to that behavior."; + reference + "Section 4 of RFC 6619"; + + } + + list nat-pass-through { +// if-feature basic-nat44 or napt44 or dst-nat; + key "id"; + description + "IP prefix NAT pass through."; + leaf id { + type uint32; + description + "An identifier of the IP prefix pass through."; + } + + leaf prefix { + type inet:ip-prefix; + mandatory true; + description + "The IP addresses that match should not be translated. + + According to REQ#6 of RFC6888, it must be possible to + administratively turn off translation for specific + destination addresses and/or ports."; + reference + "REQ#6 of RFC6888."; + + } + + leaf port { + type inet:port-number; + description + "According to REQ#6 of RFC6888, it must be possible to + administratively turn off translation for specific + destination addresses and/or ports. + + If no prefix is defined, the NAT pass through bound + to a given port applies for any destination address."; + reference + "REQ#6 of RFC6888."; + + } + } // list nat-pass-through + + list policy { + key "id"; + description + "NAT parameters for a given instance"; + leaf id { + type uint32; + description + "An identifier of the NAT policy. It must be unique + within the NAT instance."; + } + + container clat-parameters { + if-feature clat; + description "CLAT parameters."; + list clat-ipv6-prefixes { + key "ipv6-prefix"; + description + "464XLAT double translation treatment is stateless when a + dedicated /64 is available for translation on the CLAT. + Otherwise, the CLAT will have both stateful and stateless + since it requires NAT44 from the LAN to a single IPv4 + address and then stateless translation to a single + IPv6 address."; + reference + "RFC 6877: 464XLAT: Combination of Stateful and Stateless + Translation"; + + leaf ipv6-prefix { + type inet:ipv6-prefix; + description + "An IPv6 prefix used for CLAT."; + } + } // list clat-ipv6-prefixes + + list ipv4-prefixes { + key "ipv4-prefix"; + description + "Pool of IPv4 addresses used for CLAT. + 192.0.0.0/29 is the IPv4 service continuity prefix."; + reference + "RFC 7335: IPv4 Service Continuity Prefix"; + + leaf ipv4-prefix { + type inet:ipv4-prefix; + description + "464XLAT double translation treatment is + stateless when a dedicated /64 is available + for translation on the CLAT. Otherwise, the + CLAT will have both stateful and stateless + since it requires NAT44 from the LAN to + a single IPv4 address and then stateless + translation to a single IPv6 address. + The CLAT performs NAT44 for all IPv4 LAN + packets so that all the LAN-originated IPv4 + packets appear from a single IPv4 address + and are then statelessly translated to one + interface IPv6 address that is claimed by + the CLAT. + + An IPv4 address from this pool is also + provided to an application that makes + use of literals."; + reference + "RFC 6877: 464XLAT: Combination of Stateful and Stateless + Translation"; + + } + } // list ipv4-prefixes + } // container clat-parameters + + list nptv6-prefixes { + if-feature nptv6; + key "internal-ipv6-prefix"; + description + "Provides one or a list of (internal IPv6 prefix, + external IPv6 prefix) required for NPTv6. + + In its simplest form, NPTv6 interconnects two network + links, one of which is an 'internal' network link + attached to a leaf network within a single + administrative domain and the other of which is an + 'external' network with connectivity to the global + Internet."; + reference + "RFC 6296: IPv6-to-IPv6 Network Prefix Translation"; + + leaf internal-ipv6-prefix { + type inet:ipv6-prefix; + mandatory true; + description + "An IPv6 prefix used by an internal interface of NPTv6."; + reference + "RFC 6296: IPv6-to-IPv6 Network Prefix Translation"; + + } + + leaf external-ipv6-prefix { + type inet:ipv6-prefix; + mandatory true; + description + "An IPv6 prefix used by the external interface of NPTv6."; + reference + "RFC 6296: IPv6-to-IPv6 Network Prefix Translation"; + + } + } // list nptv6-prefixes + + list eam { + if-feature eam; + key "ipv4-prefix"; + description + "The Explicit Address Mapping Table, a conceptual + table in which each row represents an EAM. + + Each EAM describes a mapping between IPv4 and IPv6 + prefixes/addresses."; + reference + "Section 3.1 of RFC 7757."; + + leaf ipv4-prefix { + type inet:ipv4-prefix; + mandatory true; + description + "The IPv4 prefix of an EAM."; + reference + "Section 3.2 of RFC 7757."; + + } + + leaf ipv6-prefix { + type inet:ipv6-prefix; + mandatory true; + description + "The IPv6 prefix of an EAM."; + reference + "Section 3.2 of RFC 7757."; + + } + } // list eam + + list nat64-prefixes { +// if-feature siit or nat64 or clat; + key "nat64-prefix"; + description + "Provides one or a list of NAT64 prefixes + with or without a list of destination IPv4 prefixes. + + Destination-based Pref64::/n is discussed in + Section 5.1 of [RFC7050]). For example: + 192.0.2.0/24 is mapped to 2001:db8:122:300::/56. + 198.51.100.0/24 is mapped to 2001:db8:122::/48."; + reference + "Section 5.1 of RFC7050."; + + leaf nat64-prefix { + type inet:ipv6-prefix; + mandatory true; + description + "A NAT64 prefix. Can be Network-Specific Prefix (NSP) or + Well-Known Prefix (WKP). + + Organizations deploying stateless IPv4/IPv6 translation + should assign a Network-Specific Prefix to their + IPv4/IPv6 translation service. + + For stateless NAT64, IPv4-translatable IPv6 addresses + must use the selected Network-Specific Prefix. + + Both IPv4-translatable IPv6 addresses and IPv4-converted + IPv6 addresses should use the same prefix."; + reference + "Sections 3.3 and 3.4 of RFC 6052."; + + } + + list destination-ipv4-prefix { + key "ipv4-prefix"; + description + "An IPv4 prefix/address."; + leaf ipv4-prefix { + type inet:ipv4-prefix; + description + "An IPv4 address/prefix."; + } + } // list destination-ipv4-prefix + + leaf stateless-enable { + type boolean; + default 'false'; + description + "Enable explicitly stateless NAT64."; + } + } // list nat64-prefixes + + list external-ip-address-pool { +// if-feature basic-nat44 or napt44 or nat64; + key "pool-id"; + description + "Pool of external IP addresses used to service internal + hosts. + + A pool is a set of IP prefixes."; + leaf pool-id { + type uint32; + must ". >= 1"; + description + "An identifier that uniquely identifies the address pool + within a NAT instance. + + The identifier must be greater than zero as per + RFC 7659."; + reference + "RFC 7659: Definitions of Managed Objects for + Network Address Translators (NATs)"; + + } + + leaf external-ip-pool { + type inet:ipv4-prefix; + mandatory true; + description + "An IPv4 prefix used for NAT purposes."; + } + } // list external-ip-address-pool + + container port-set-restrict { +// if-feature napt44 or nat64; + description + "Configures contiguous and non-contiguous port ranges. + + The port set is used to restrict the external source + port numbers used by the translator."; + uses port-set; + } // container port-set-restrict + + leaf dst-nat-enable { +// if-feature basic-nat44 or napt44; + type boolean; + default 'false'; + description + "Enable/Disable destination NAT. + + A NAT44 may be configured to enable Destination + NAT, too."; + } + + list dst-ip-address-pool { +// if-feature dst-nat; + key "pool-id"; + description + "Pool of IP addresses used for destination NAT."; + leaf pool-id { + type uint32; + description + "An identifier of the address pool."; + } + + leaf dst-in-ip-pool { + type inet:ip-prefix; + description + "Is used to identify an internal IP prefix/address + to be translated."; + } + + leaf dst-out-ip-pool { + type inet:ip-prefix; + mandatory true; + description + "IP address/prefix used for destination NAT."; + } + } // list dst-ip-address-pool + + list transport-protocols { +// if-feature napt44 or nat64 or dst-nat; + key "protocol-id"; + description + "Configure the transport protocols to be handled by + the translator. + + TCP and UDP are supported by default."; + leaf protocol-id { + type uint8; + mandatory true; + description + "Upper-layer protocol associated with this mapping. + + Values are taken from the IANA protocol registry: + https://www.iana.org/assignments/protocol-numbers/ + protocol-numbers.xhtml + + For example, this field contains 6 (TCP) for a TCP + mapping or 17 (UDP) for a UDP mapping."; + } + + leaf protocol-name { + type string; + description + "The name of the Upper-layer protocol associated + with this mapping. + + Values are taken from the IANA protocol registry: + https://www.iana.org/assignments/protocol-numbers/ + protocol-numbers.xhtml + + For example, TCP, UDP, DCCP, and SCTP."; + } + } // list transport-protocols + + leaf subscriber-mask-v6 { + type uint8 { + range "0 .. 128"; + } + description + "The subscriber mask is an integer that indicates + the length of significant bits to be applied on + the source IPv6 address (internal side) to + unambiguously identify a user device (e.g., CPE). + + Subscriber mask is a system-wide configuration + parameter that is used to enforce generic + per-subscriber policies (e.g., port-quota). + + The enforcement of these generic policies does not + require the configuration of every subscriber's + prefix. + + Example: suppose the 2001:db8:100:100::/56 prefix + is assigned to a NAT64 serviced CPE. Suppose also + that 2001:db8:100:100::1 is the IPv6 address used + by the client that resides in that CPE. When the + NAT64 receives a packet from this client, + it applies the subscriber-mask-v6 (e.g., 56) on + the source IPv6 address to compute the associated + prefix for this client (2001:db8:100:100::/56). + Then, the NAT64 enforces policies based on that + prefix (2001:db8:100:100::/56), not on the exact + source IPv6 address."; + } + + list subscriber-match { +// if-feature basic-nat44 or napt44 or dst-nat; + key "match-id"; + description + "IP prefix match. + A subscriber is identified by a subnet."; + leaf match-id { + type uint32; + description + "An identifier of the subscriber match."; + } + + leaf subnet { + type inet:ip-prefix; + mandatory true; + description + "The IP address subnets that match + should be translated. E.g., all addresses + that belong to the 192.0.2.0/24 prefix must + be processed by the NAT."; + } + } // list subscriber-match + + leaf address-allocation-type { + type enumeration { + enum "arbitrary" { + value 0; + description + "Arbitrary pooling behavior means that the NAT + instance may create the new port mapping using any + address in the pool that has a free port for the + protocol concerned."; + } + enum "roundrobin" { + value 1; + description + "Round robin allocation."; + } + enum "paired" { + value 2; + description + "Paired address pooling informs the NAT + that all the flows from an internal IP + address must be assigned the same external + address. This is the recommended behavior for + NAPT/NAT64."; + reference + "RFC 4787: Network Address Translation (NAT) + Behavioral Requirements for Unicast UDP"; + + } + } + description + "Specifies how external IP addresses are allocated."; + } + + leaf port-allocation-type { +// if-feature napt44 or nat64; + type enumeration { + enum "random" { + value 0; + description + "Port randomization is enabled. A NAT port allocation + scheme should make it hard for attackers to guess + port numbers"; + reference + "REQ-15 of RFC 6888"; + + } + enum "port-preservation" { + value 1; + description + "Indicates whether the NAT should preserve the internal + port number."; + } + enum + "port-parity-preservation" { + value 2; + description + "Indicates whether the NAT should preserve the port + parity of the internal port number."; + } + enum "port-range-allocation" { + value 3; + description + "Indicates whether the NAT assigns a range of ports + for an internal host. This scheme allows to minimize + log volume."; + reference + "REQ-14 of RFC 6888"; + + } + } + description + "Indicates the type of port allocation."; + } + + leaf mapping-type { +// if-feature napt44 or nat64; + type enumeration { + enum "eim" { + value 0; + description + "endpoint-independent-mapping."; + reference + "Section 4 of RFC 4787."; + + } + enum "adm" { + value 1; + description + "address-dependent-mapping."; + reference + "Section 4 of RFC 4787."; + + } + enum "edm" { + value 2; + description + "address-and-port-dependent-mapping."; + reference + "Section 4 of RFC 4787."; + + } + } + description + "Indicates the type of a NAT mapping."; + } + + leaf filtering-type { +// if-feature napt44 or nat64; + type enumeration { + enum "eif" { + value 0; + description + "endpoint-independent-filtering."; + reference + "Section 5 of RFC 4787."; + + } + enum "adf" { + value 1; + description + "address-dependent-filtering."; + reference + "Section 5 of RFC 4787."; + + } + enum "edf" { + value 2; + description + "address-and-port-dependent-filtering"; + reference + "Section 5 of RFC 4787."; + + } + } + description + "Indicates the type of a NAT filtering."; + } + + leaf fragment-behavior { +// if-feature napt44 or nat64; + type enumeration { + enum "drop-all" { + value 0; + description + "All received fragments are dropped."; + } + enum "in-order" { + value 1; + description + "Translate fragments only if they are received + in order."; + } + enum "out-of-order" { + value 2; + description + "Translate a fragment even if it is received out + of order. + + This behavior is the recommended behavior."; + reference + "REQ-14 of RFC 4787"; + + } + } + description + "The fragment behavior instructs the NAT about the + behavior to follow to translate fragments received + on the external interface of the NAT."; + } + + list port-quota { +// if-feature napt44 or nat64; + key "quota-type"; + description + "Configures a port quota to be assigned per subscriber. + It corresponds to the maximum number of ports to be + used by a subscriber."; + leaf port-limit { + type uint16; + description + "Configures a port quota to be assigned per subscriber. + It corresponds to the maximum number of ports to be + used by a subscriber."; + reference + "REQ-4 of RFC 6888."; + + } + + leaf quota-type { + type uint8; + description + "Indicates whether the port quota applies to + all protocols (0) or to a specific protocol."; + } + } // list port-quota + + container port-set { + when + "../port-allocation-type = 'port-range-allocation'"; +// if-feature napt44 or nat64; + description + "Manages port-set assignments."; + leaf port-set-size { + type uint16; + mandatory true; + description + "Indicates the size of assigned port sets."; + } + + leaf port-set-timeout { + type uint32; + units "seconds"; + description + "inactivity timeout for port sets."; + } + } // container port-set + + container timers { +// if-feature napt44 or nat64; + description + "Configure values of various timeouts."; + leaf udp-timeout { + type uint32; + units "seconds"; + default '300'; + description + "UDP inactivity timeout. That is the time a mapping + will stay active without packets traversing the NAT."; + reference + "RFC 4787: Network Address Translation (NAT) + Behavioral Requirements for Unicast UDP"; + + } + + leaf tcp-idle-timeout { + type uint32; + units "seconds"; + default '7440'; + description + "TCP Idle timeout should be 2 hours and 4 minutes."; + reference + "RFC 5382: NAT Behavioral Requirements for TCP"; + + } + + leaf tcp-trans-open-timeout { + type uint32; + units "seconds"; + default '240'; + description + "The value of the transitory open connection + idle-timeout. + + Section 2.1 of [RFC7857] clarifies that a NAT + should provide different configurable + parameters for configuring the open and + closing idle timeouts. + + To accommodate deployments that consider + a partially open timeout of 4 minutes as being + excessive from a security standpoint, a NAT may + allow the configured timeout to be less than + 4 minutes. + + However, a minimum default transitory connection + idle-timeout of 4 minutes is recommended."; + reference + "Section 2.1 of RFC 7857."; + + } + + leaf tcp-trans-close-timeout { + type uint32; + units "seconds"; + default '240'; + description + "The value of the transitory close connection + idle-timeout. + Section 2.1 of [RFC7857] clarifies that a NAT + should provide different configurable + parameters for configuring the open and + closing idle timeouts."; + reference + "Section 2.1 of RFC 7857."; + + } + + leaf tcp-in-syn-timeout { + type uint32; + units "seconds"; + default '6'; + description + "A NAT must not respond to an unsolicited + inbound SYN packet for at least 6 seconds + after the packet is received. If during + this interval the NAT receives and translates + an outbound SYN for the connection the NAT + must silently drop the original unsolicited + inbound SYN packet."; + reference + "RFC 5382 NAT Behavioral Requirements for TCP"; + + } + + leaf fragment-min-timeout { + when + "../../fragment-behavior='out-of-order'"; + type uint32; + units "seconds"; + default '2'; + description + "As long as the NAT has available resources, + the NAT allows the fragments to arrive + over fragment-min-timeout interval. + The default value is inspired from RFC6146."; + } + + leaf icmp-timeout { + type uint32; + units "seconds"; + default '60'; + description + "An ICMP Query session timer must not expire + in less than 60 seconds. It is recommended + that the ICMP Query session timer be made + configurable"; + reference + "RFC 5508: NAT Behavioral Requirements for ICMP"; + + } + + list per-port-timeout { + key "port-number"; + description + "Some NATs are configurable with short timeouts + for some ports, e.g., as 10 seconds on + port 53 (DNS) and 123 (NTP) and longer timeouts + on other ports."; + leaf port-number { + type inet:port-number; + description + "A port number."; + } + + leaf timeout { + type uint32; + units "seconds"; + mandatory true; + description + "Timeout for this port number"; + } + } // list per-port-timeout + + leaf hold-down-timeout { + type uint32; + units "seconds"; + default '120'; + description + "Hold down timer. + + Ports in the hold down pool are not reassigned until + hold-down-timeout expires. + + The length of time and the maximum number of ports in + this state must be configurable by the administrator. + + This is necessary in order to prevent collisions + between old and new mappings and sessions. It ensures + that all established sessions are broken instead of + redirected to a different peer."; + reference + "REQ#8 of RFC 6888."; + + } + + leaf hold-down-max { + type uint32; + description + "Maximum ports in the Hold down timer pool. + Ports in the hold down pool are not reassigned + until hold-down-timeout expires. + + The length of time and the maximum + number of ports in this state must be + configurable by the administrator. + This is necessary in order + to prevent collisions between old + and new mappings and sessions. It ensures + that all established sessions are broken + instead of redirected to a different peer."; + reference + "REQ#8 of RFC 6888."; + + } + } // container timers + + leaf fragments-limit { + when + "../fragment-behavior='out-of-order'"; + type uint32; + description + "Limits the number of out of order fragments that can + be handled."; + reference + "Section 11 of RFC 4787."; + + } + + list algs { + key "name"; + description + "ALG-related features."; + leaf name { + type string; + description + "The name of the ALG."; + } + + leaf transport-protocol { + type uint32; + description + "The transport protocol used by the ALG + (e.g., TCP, UDP)."; + } + + container dst-transport-port { + description + "The destination port number(s) used by the ALG. + For example, + - 21 for the FTP ALG + - 53 for the DNS ALG."; + uses port-number; + } // container dst-transport-port + + container src-transport-port { + description + "The source port number(s) used by the ALG."; + uses port-number; + } // container src-transport-port + + leaf status { + type boolean; + description + "Enable/disable the ALG."; + } + } // list algs + + leaf all-algs-enable { + type boolean; + description + "Enable/disable all ALGs. + + When specified, this parameter overrides the one + that may be indicated, eventually, by the 'status' + of an individual ALG."; + } + + container notify-pool-usage { +// if-feature basic-nat44 or napt44 or nat64; + description + "Notification of pool usage when certain criteria + are met."; + leaf pool-id { + type uint32; + description + "Pool-ID for which the notification criteria + is defined"; + } + + leaf high-threshold { + type percent; + description + "Notification must be generated when the defined high + threshold is reached. + + For example, if a notification is required when the + pool utilization reaches 90%, this configuration + parameter must be set to 90. + + 0% indicates that no high threshold is enabled."; + } + + leaf low-threshold { + type percent; + must + ". >= ../high-threshold" { + error-message + "The upper port number must be greater than or + equal to lower port number."; + } + description + "Notification must be generated when the defined low + threshold is reached. + + For example, if a notification is required when the + pool utilization reaches below 10%, this + configuration parameter must be set to 10"; + } + + leaf notify-interval { + type uint32 { + range "1 .. 3600"; + } + units "seconds"; + default '20'; + description + "Minimum number of seconds between successive + notifications for this pool."; + reference + "RFC 7659: Definitions of Managed Objects for + Network Address Translators (NATs)"; + + } + } // container notify-pool-usage + + container external-realm { + description + "Identifies the external realm of the NAT instance."; + choice realm-type { + description + "Can be an interface, VRF instance, etc."; + case interface { + description + "External interface."; + leaf external-interface { + type if:interface-ref; + description + "Name of the external interface."; + } + } // case interface + } // choice realm-type + } // container external-realm + } // list policy + + container mapping-limits { +// if-feature napt44 or nat64; + description + "Information about the configuration parameters that + limits the mappings based upon various criteria."; + leaf limit-subscribers { + type uint32; + description + "Maximum number of subscribers that can be serviced + by a NAT instance. + + A subscriber is identified by a given prefix."; + reference + "RFC 7659: Definitions of Managed Objects for + Network Address Translators (NATs)"; + + } + + leaf limit-address-mapings { + type uint32; + description + "Maximum number of address mappings that can be + handled by a NAT instance. + + When this limit is reached, packets that would + normally trigger translation, will be dropped."; + reference + "RFC 7659: Definitions of Managed Objects + for Network Address Translators + (NATs)"; + + } + + leaf limit-port-mappings { + type uint32; + description + "Maximum number of port mappings that can be handled + by a NAT instance. + + When this limit is reached, packets that would + normally trigger translation, will be dropped."; + reference + "RFC 7659: Definitions of Managed Objects for + Network Address Translators (NATs)"; + + } + + list limit-per-protocol { +// if-feature napt44 or nat64 or dst-nat; + key "protocol-id"; + description + "Configure limits per transport protocol"; + leaf protocol-id { + type uint8; + mandatory true; + description + "Upper-layer protocol associated with this mapping. + + Values are taken from the IANA protocol registry: + https://www.iana.org/assignments/protocol-numbers/ + protocol-numbers.xhtml + + For example, this field contains 6 (TCP) for a TCP + mapping or 17 (UDP) for a UDP mapping."; + } + + leaf limit { + type uint32; + description + "Maximum number of protocol-specific NAT mappings + per instance."; + } + } // list limit-per-protocol + } // container mapping-limits + + container connection-limits { +// if-feature basic-nat44 or napt44 or nat64; + description + "Information about the configuration parameters that + rate limit the translation based upon various criteria."; + leaf limit-per-subscriber { + type uint32; + units "bits/second"; + description + "Rate-limit the number of new mappings and sessions + per subscriber."; + } + + leaf limit-per-instance { + type uint32; + units "bits/second"; + mandatory true; + description + "Rate-limit the number of new mappings and sessions + per instance."; + } + + list limit-per-protocol { +// if-feature napt44 or nat64; + key "protocol-id"; + description + "Configure limits per transport protocol"; + leaf protocol-id { + type uint8; + mandatory true; + description + "Upper-layer protocol associated with this mapping. + + Values are taken from the IANA protocol registry: + https://www.iana.org/assignments/protocol-numbers/ + protocol-numbers.xhtml + + For example, this field contains 6 (TCP) for a TCP + mapping or 17 (UDP) for a UDP mapping."; + } + + leaf limit { + type uint32; + description + "Rate-limit the number of protocol-specific mappings + and sessions per instance."; + } + } // list limit-per-protocol + } // container connection-limits + + container notification-limits { + description + "Sets notification limits."; + leaf notify-interval { +// if-feature basic-nat44 or napt44 or nat64; + type uint32 { + range "1 .. 3600"; + } + units "seconds"; + default '10'; + description + "Minimum number of seconds between successive + notifications for this NAT instance."; + reference + "RFC 7659: Definitions of Managed Objects + for Network Address Translators (NATs)"; + + } + + leaf notify-addresses-usage { +// if-feature basic-nat44 or napt44 or nat64; + type percent; + description + "Notification of address mappings usage over + the whole NAT instance. + + Notification must be generated when the defined + threshold is reached. + + For example, if a notification is required when + the address mappings utilization reaches 90%, + this configuration parameter must be set + to 90."; + } + + leaf notify-ports-usage { +// if-feature napt44 or nat64; + type percent; + description + "Notification of port mappings usage over the + whole NAT instance. + + Notification must be generated when the defined + threshold is reached. + + For example, if a notification is required when + the port mappings utilization reaches 90%, this + configuration parameter must be set to 90."; + } + + leaf notify-subscribers-limit { +// if-feature basic-nat44 or napt44 or nat64; + type uint32; + description + "Notification of active subscribers per NAT + instance. + + Notification must be generated when the defined + threshold is reached."; + } + } // container notification-limits + + leaf logging-enable { +// if-feature basic-nat44 or napt44 or nat64; + type boolean; + description + "Enable logging features."; + reference + "Section 2.3 of RFC 6908 and REQ-12 of RFC6888."; + + } + + container mapping-table { +// if-feature basic-nat44 or napt44 or nat64 or clat or dst-nat; + description + "NAT mapping table. Applicable for functions which maintain + static and/or dynamic mappings, such as NAT44, Destination + NAT, NAT64, or CLAT."; + list mapping-entry { + key "index"; + description + "NAT mapping entry."; + uses mapping-entry; + } // list mapping-entry + } // container mapping-table + + container statistics { + config false; + description + "Statistics related to the NAT instance."; + leaf discontinuity-time { + type yang:date-and-time; + mandatory true; + description + "The time on the most recent occasion at which the NAT + instance suffered a discontinuity. This must be + initialized when the NAT instance is configured + or rebooted."; + } + + container traffic-statistics { + description + "Generic traffic statistics."; + leaf sent-packets { + type yang:zero-based-counter64; + description + "Number of packets sent."; + } + + leaf sent-bytes { + type yang:zero-based-counter64; + units "bytes"; + description + "Counter for sent traffic in bytes."; + } + + leaf rcvd-packets { + type yang:zero-based-counter64; + description + "Number of received packets."; + } + + leaf rcvd-bytes { + type yang:zero-based-counter64; + units "bytes"; + description + "Counter for received traffic in bytes."; + } + + leaf dropped-packets { + type yang:zero-based-counter64; + description + "Number of dropped packets."; + } + + leaf dropped-bytes { + type yang:zero-based-counter64; + units "bytes"; + description + "Counter for dropped traffic in bytes."; + } + + leaf dropped-fragments { +// if-feature napt44 or nat64; + type yang:zero-based-counter64; + description + "Number of dropped fragments on the external realm."; + } + + leaf dropped-address-limit-packets { +// if-feature basic-nat44 or napt44 or nat64; + type yang:zero-based-counter64; + description + "Number of dropped packets because an address limit + is reached."; + } + + leaf dropped-address-limit-bytes { +// if-feature basic-nat44 or napt44 or nat64; + type yang:zero-based-counter64; + units "bytes"; + description + "Counter of dropped packets because an address limit + is reached, in bytes."; + } + + leaf dropped-address-packets { +// if-feature basic-nat44 or napt44 or nat64; + type yang:zero-based-counter64; + description + "Number of dropped packets because no address is + available for allocation."; + } + + leaf dropped-address-bytes { +// if-feature basic-nat44 or napt44 or nat64; + type yang:zero-based-counter64; + units "bytes"; + description + "Counter of dropped packets because no address is + available for allocation, in bytes."; + } + + leaf dropped-port-limit-packets { +// if-feature napt44 or nat64; + type yang:zero-based-counter64; + description + "Number of dropped packets because a port limit + is reached."; + } + + leaf dropped-port-limit-bytes { +// if-feature napt44 or nat64; + type yang:zero-based-counter64; + units "bytes"; + description + "Counter of dropped packets because a port limit + is reached, in bytes."; + } + + leaf dropped-port-packets { +// if-feature napt44 or nat64; + type yang:zero-based-counter64; + description + "Number of dropped packets because no port is + available for allocation."; + } + + leaf dropped-port-bytes { +// if-feature napt44 or nat64; + type yang:zero-based-counter64; + units "bytes"; + description + "Counter of dropped packets because no port is + available for allocation, in bytes."; + } + + leaf dropped-subscriber-limit-packets { +// if-feature basic-nat44 or napt44 or nat64; + type yang:zero-based-counter64; + description + "Number of dropped packets because the subscriber + limit per instance is reached."; + } + + leaf dropped-subscriber-limit-bytes { +// if-feature basic-nat44 or napt44 or nat64; + type yang:zero-based-counter64; + units "bytes"; + description + "Counter of dropped packets because the subscriber + limit per instance is reached, in bytes."; + } + } // container traffic-statistics + + container mappings-statistics { + description + "Mappings statistics."; + leaf total-active-subscribers { +// if-feature basic-nat44 or napt44 or nat64; + type yang:gauge32; + description + "Total number of active subscribers (that is, subscribers + for which the NAT maintains active mappings. + + A subscriber is identified by a subnet, subscriber-mask, + etc."; + } + + leaf total-address-mappings { +// if-feature basic-nat44 or napt44 or nat64 or clat or dst-nat; + type yang:gauge32; + description + "Total number of address mappings present at a given + time. It includes both static and dynamic mappings."; + reference + "Section 3.3.8 of RFC 7659"; + + } + + leaf total-port-mappings { +// if-feature napt44 or nat64; + type yang:gauge32; + description + "Total number of NAT port mappings present at + a given time. It includes both static and dynamic + mappings."; + reference + "Section 3.3.9 of RFC 7659"; + + } + + list total-per-protocol { +// if-feature napt44 or nat64; + key "protocol-id"; + description + "Total mappings for each enabled/supported protocol."; + leaf protocol-id { + type uint8; + mandatory true; + description + "Upper-layer protocol associated with this mapping. + For example, this field contains 6 (TCP) for a TCP + mapping or 17 (UDP) for a UDP mapping."; + } + + leaf total { + type yang:gauge32; + description + "Total number of a protocol-specific mappings present + at a given time. The protocol is identified by + protocol-id."; + } + } // list total-per-protocol + } // container mappings-statistics + + container pools-stats { +// if-feature basic-nat44 or napt44 or nat64; + description + "Statistics related to address/prefix pools + usage"; + leaf addresses-allocated { + type yang:gauge32; + description + "Number of all allocated addresses."; + } + + leaf addresses-free { + type yang:gauge32; + description + "Number of unallocated addresses of all pools at + a given time. The sum of unallocated and allocated + addresses is the total number of addresses of + the pools."; + } + + container ports-stats { +// if-feature napt44 or nat64; + description + "Statistics related to port numbers usage."; + leaf ports-allocated { + type yang:gauge32; + description + "Number of allocated ports from all pools."; + } + + leaf ports-free { + type yang:gauge32; + description + "Number of unallocated addresses from all pools."; + } + } // container ports-stats + + list per-pool-stats { +// if-feature basic-nat44 or napt44 or nat64; + key "pool-id"; + description + "Statistics related to address/prefix pool usage"; + leaf pool-id { + type uint32; + description + "Unique Identifier that represents a pool of + addresses/prefixes."; + } + + leaf discontinuity-time { + type yang:date-and-time; + mandatory true; + description + "The time on the most recent occasion at which this + pool counters suffered a discontinuity. This must + be initialized when the address pool is + configured."; + } + + container pool-stats { + description + "Statistics related to address/prefix pool usage"; + leaf addresses-allocated { + type yang:gauge32; + description + "Number of allocated addresses from this pool."; + } + + leaf addresses-free { + type yang:gauge32; + description + "Number of unallocated addresses in this pool."; + } + } // container pool-stats + + container port-stats { +// if-feature napt44 or nat64; + description + "Statistics related to port numbers usage."; + leaf ports-allocated { + type yang:gauge32; + description + "Number of allocated ports from this pool."; + } + + leaf ports-free { + type yang:gauge32; + description + "Number of unallocated addresses from this pool."; + } + } // container port-stats + } // list per-pool-stats + } // container pools-stats + } // container statistics + } // list instance + } // container instances + } // container nat + + notification nat-pool-event { +// if-feature basic-nat44 or napt44 or nat64; + description + "Notifications must be generated when the defined high/low + threshold is reached. Related configuration parameters + must be provided to trigger the notifications."; + leaf id { + type leafref { + path "/nat/instances/instance/id"; + } + mandatory true; + description + "NAT instance Identifier."; + } + + leaf policy-id { + type leafref { + path "/nat/instances/instance/policy/id"; + } + description "Policy Identifier."; + } + + leaf pool-id { + type leafref { + path "/nat/instances/instance/policy/external-ip-address-pool/pool-id"; + } + mandatory true; + description "Pool Identifier."; + } + + leaf notify-pool-threshold { + type percent; + mandatory true; + description + "A threshold (high-threshold or low-threshold) has + been fired."; + } + } // notification nat-pool-event + + notification nat-instance-event { +// if-feature basic-nat44 or napt44 or nat64; + description + "Notifications must be generated when notify-addresses-usage + and/or notify-ports-usage threshold are reached."; + leaf id { + type leafref { + path "/nat/instances/instance/id"; + } + mandatory true; + description + "NAT instance Identifier."; + } + + leaf notify-subscribers-threshold { + type uint32; + description + "The notify-subscribers-limit threshold has been fired."; + } + + leaf notify-addresses-threshold { + type percent; + description + "The notify-addresses-usage threshold has been fired."; + } + + leaf notify-ports-threshold { + type percent; + description + "The notify-ports-usage threshold has been fired."; + } + } // notification nat-instance-event + } // module ietf-nat -- cgit 1.2.3-korg