netgate-ntp.yang

module netgate-ntp {

    yang-version 1.1;

    namespace "urn:netgate:xml:yang:netgate-ntp";
    prefix "ngntp";

    import ietf-inet-types {
	prefix "inet";
    }

    import netgate-cli-extensions {
	prefix "ngcliext";
    }

    import netgate-common {
	prefix "ngcom";
    }

    organization "Netgate";

    contact "Web: <http://www.netgate.com>";

    description
	"This YANG module provides a data-model for the NTP service.

	 Copyright 2018-2020 Rubicon Communications, LLC.
	";

    revision 2021-11-15 {
	description
	    "TNSR Release 21.11.";
    }

    revision 2021-02-15 {
	description
	    "TNSR Release 21.02.";
    }

    revision 2020-06-15 {
	description
	    "TNSR Release 20.06.";
    }

    revision 2020-02-15 {
	description
	    "TNSR Release 20.02.";
    }

    revision 2019-05-30 {
	description
	    "TNSR Release 19.05.";
    }

    revision 2019-02-15 {
	description
	    "TNSR Release 19.02.";
    }

    revision 2018-05-17 {
	description
	    "Initial Revision.";
    }

    typedef ntp-restriction-special {
	type enumeration {
	    enum default {
		description
		    "Default restrictions";
	    }
	    enum source {
		description
		    "Source restrictions";
	    }
	}
	description
	    "Enumeration of special NTP restriction values other than
	     network specifications.";
    }

    typedef ntp-restriction-address {
	type union {
	    type inet:ip-prefix;
	    type inet:domain-name;
	    type ntp-restriction-special;
	}
	description
	    "NTP restriction address type which can be a special name
	     or an IP prefix.";

    }

    typedef ntp-interface-action {
	type enumeration {
	    enum listen {
		description
		    "Listen for matching packets.";
	    }
	    enum ignore {
		description
		    "Prevent opening matching packets.";
	    }
	    enum drop {
		description
		    "Drop causes ntpd to open the address and drop all
		     the received packets without examination.";
	    }
	}
	description
	    "List of special interface address class names.";

    }

    typedef ntp-server-mode {
	type enumeration {
	    enum server {
		description
		    "Server";
	    }
	    enum pool {
		description
		    "Pool";
	    }
	}
	description
	    "Enumeration of server types.";

    }

    typedef ntp-log-action {
	type enumeration {
	    enum set {
		description
		    "Set";
	    }
	    enum add {
		description
		    "Add";
	    }
	    enum delete {
		description
		    "Delete";
	    }
	}
    }

    typedef ntp-log-class {
	type enumeration {
	    enum all {
		description
		    "All";
	    }
	    enum clock {
		description
		    "Clock";
	    }
	    enum peer {
		description
		    "Peer";
	    }
	    enum sys {
		description
		    "Sys";
	    }
	    enum sync {
		description
		    "Sync";
	    }
	}
    }

    typedef ntp-log-type {
	type enumeration {
	    enum all {
		description
		    "All";
	    }
	    enum info {
		description
		    "Info";
	    }
	    enum events {
		description
		    "events";
	    }
	    enum statistics {
		description
		    "Statistics";
	    }
	    enum status {
		description
		    "Status";
	    }
	}
    }

    typedef ntp-selection {
	type enumeration {
	    enum "rejected" {
		description
		    "rejected";
	    }

	    enum "falsetick" {
		description
		    "discarded by intersection algorithm";
	    }

	    enum "excess" {
		description
		    "discarded by table overflow";
	    }

	    enum "outlier" {
		description
		    "discarded by cluster algorithm";
	    }

	    enum "candidate" {
		description
		    "included by the combine algorithm";
	    }

	    enum "backup" {
		description
		    "backup source";
	    }

	    enum "sys.peer" {
		description
		    "synchronization source";
	    }

	    enum "pps.peer" {
		description
		    "Pulse per second peer";
	    }
	}
    }


    typedef ntp-event {
	type enumeration {
	    enum "unspecified" {
		description
		    "unspecified";
	    }

	    enum "mobilize" {
		description
		    "association mobilized";
	    }

	    enum "demobilized" {
		description
		    "association demobilized";
	    }

	    enum "unreachable" {
		description
		    "peer unreachable (peer.reach was nonzero now zero)";
	    }

	    enum "rechable" {
		description
		    "peer reachable (peer.reach was zero now nonzero)";
	    }

	    enum "restart" {
		description
		    "association restarted or timed out";
	    }

	    enum "no_reply" {
		description
		    "no reply (only used with one-shot ntpd -q)";
	    }

	    enum "rate_exceeded" {
		description
		    "peer rate limit exceeded (kiss code RATE received)";
	    }

	    enum "access_denied" {
		description
		    "access denied (kiss code DENY received)";
	    }

	    enum "leap_armed" {
		description
		    "leap second insertion/deletion at month's end
		     armed by peer vote";
	    }

	    enum "sys_peer" {
		description
		    "became system peer (sys.peer)";
	    }

	    enum "clock_event" {
		description
		    "reference clock event (see clock status word)";
	    }

	    enum "bad_auth" {
		description
		    "authentication failed";
	    }

	    enum "popcorn" {
		description
		    "popcorn spike suppressed by peer clock filter register";
	    }

	    enum "interleave_mode" {
		description
		    "entering interleaved mode";
	    }

	    enum "interleave_error" {
		description
		    "recovered from interleave error";
	    }
	}
    }


    container ntp-config {
	description
	    "Network Time Protocol daemon configuration for time
	     keeping and services.";

	container system {
	    description
		"The NTP system parameters not managed by the daemon.";

	    ngcliext:parent-fmt "ntp";

	    leaf namespace {
		type ngcom:network-namespace;
		description
		    "Network namespace to be used by NTP daemon.";
		ngcliext:node-fmt "$< $% @@$n";
	    }

	    leaf enable {
		type boolean;
		description
		    "If true, the NTP daemon is enabled.";
		ngcliext:node-op "bool";
		ngcliext:node-fmt "|$< $%$n";
	    }
	}

	container daemon {
	    description
		"NTP daemon configuration parameters.";

	    ngcliext:node-fmt "ntp server$n";
	    ngcliext:pre-children-op "push";

	    container parameters {
		description
		    "The NTP parameters managed by the NTP daemon.";

		leaf driftfile {
		    type string;
		    description
			"Full path name of the drift file.  If not specified,
			 /var/lib/ntp/drift.";
		    ngcliext:node-fmt "^$% @@$n";
		}

		leaf statsdir {
		    type string;
		    description
			"Full path name of the statistics directory.  If not
			 specified, /var/log/ntpstats";
		    ngcliext:node-fmt "^$% @@$n";
		}

		container disabled-flags {
		    description
			"Force monitor flags to disabled.";

		    ngcliext:parent-fmt "^disable";

		    leaf monitor {
			type boolean;
			description
			    "If true, disable monitor.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|$< $%$n";
		    }
		}

		container enabled-flags {
		    description
			"Force monitor flags to enabled.";

		    ngcliext:parent-fmt "^enable";

		    leaf monitor {
			type boolean;
			description
			    "If true, enable monitor.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|$< $%$n";
		    }
		}
	    }

	    container interfaces {
		description
		    "Interface binding specifications.";


		list interface {
		    key "sequence";

		    ngcliext:node-fmt "^interface";
		    ngcliext:children-order "sequence action match-all match-interface match-ip-prefix";

		    leaf sequence {
			type uint32;
			description
			    "The sequence numbers provide an ordering for the
			     list of interface commands.";
			ngcliext:node-fmt " sequence @@";
		    }

		    leaf action {
			type ntp-interface-action;
			description
			    "One of the action keywords listen, ignore
			     or drop to perform on a single matching
			     keyword, interface, or IP prefix.";
			ngcliext:node-fmt " @@";
		    }

		    leaf match-all {
			type boolean;
			description
			    "Match all interfaces.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "| all$n";
		    }

		    leaf match-interface {
			type string;
			description
			    "Match an interface name.";
			ngcliext:node-fmt " interface @@$n";
		    }

		    leaf match-ip-prefix {
			type inet:ip-prefix;
			description
			    "Match an IP prefix.";
			ngcliext:node-fmt " prefix @@$n";
		    }
		}
	    }

	    container logconfigs {
		description
		    "An ordered sequence of NTPD logconfig settings.";

		ngcliext:parent-fmt "^logconfig";

		list logconfig {
		    key "sequence";

		    ngcliext:node-fmt "$< sequence @{sequence} @{action} @{class} @{type}$n";

		    leaf sequence {
			type uint32;
			description
			    "Logconfig options must be ordered.";
		    }

		    leaf action {
			type ntp-log-action;
			description
			    "One of the actions 'set', 'add', or 'delete'.";
		    }

		    leaf class {
			type ntp-log-class;
			description
			    "One of the logging classes 'clock', 'peer',
			     'sys', 'sync', or 'all'.";
		    }

		    leaf type {
			type ntp-log-type;
			description
			    "One of the logging types 'info', 'events',
			     'statistics', 'status', or 'all'.";
		    }
		}
	    }

	    container restrictions {
		list restriction {
		    key "address";

		    ngcliext:node-fmt "^restrict @{address}$n";
		    ngcliext:pre-children-op "push";

		    leaf address {
			type ntp-restriction-address;
			mandatory true;
			description
			    "Network to restrict.";
		    }

		    leaf address-family {
			type ngcom:ip-address-family;
			description
			    "IP address family of this restriction.";
		    }

		    leaf kod {
			type boolean;
			description
			    "If true, enable Kiss o' Death packets.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf limited {
			type boolean;
			description
			    "If true, enable Kiss o' Death packets.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf nomodify {
			type boolean;
			description
			    "If true, deny run-time config by ntpq and ntpdc.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf noquery {
			type boolean;
			description
			    "If true, disable ntpq/ntpdc queries.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf noserve {
			type boolean;
			description
			    "If true, disable service/everything except
			     ntpq and ntpdc queries.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf nopeer {
			type boolean;
			description
			    "If true, deny peer association packets.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf notrap {
			type boolean;
			description
			    "If true, deny mode 6 control message trap
			     service.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }
		}
	    }

	    container servers {
		list server {
		    key "host";

		    ngcliext:node-fmt "^server @{host}$n";
		    ngcliext:pre-children-op "push";

		    leaf host {
			type inet:host;
			mandatory true;
			description
			    "NTP server IP address or FQDN.";
		    }

		    leaf iburst {
			type boolean;
			description
			    "If true, send a burst of attempts to an
			     unreachable server to speed up acquisition of
			     time synchronization.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf maxpoll {
			type uint8 {
			    range "7..17";
			}
			description    
			    "Maximum poll interval expressed as a power of
			     2 in seconds.";
			ngcliext:node-fmt "^$% @@$n";
		    }

		    leaf noselect {
			type boolean;
			description
			    "If true, disable time sync for this server,
			     track stats only.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }

		    leaf operational-mode {
			type ntp-server-mode;
			mandatory true;
			description
			    "One of 'server', or 'pool'.";
			ngcliext:node-fmt "^$% @@$n";
		    }

		    leaf prefer {
			type boolean;
			description
			    "If true, favor this server more than others.";
			ngcliext:node-op "bool";
			ngcliext:node-fmt "|^$%$n";
		    }
		}
	    }

	    container tinker {
		description
		    "Tinker options.";

		ngcliext:parent-fmt "^tinker";

		leaf panic {
		    type uint32;
		    description
			"Panic threshold in seconds.  0 disables.
			 Default 1000.";
		    ngcliext:node-fmt "$< $% @@$n";
		}
	    }

	    container tos {
		description
		    "TOS options.";

		ngcliext:parent-fmt "^tos";

		leaf orphan {
		    type uint8 {
			range "1..16";
		    }
		    description
			"Orphan stratum in the range 1 through 16.";
		    ngcliext:node-fmt "$< $% @@$n";
		}
	    }
	}
    }

    container ntp-state {
	config false;

	description
	    "Network Time Protocol daemon configuration for time
	     keeping and services.";

	container peers {
	    description
		"Information about the server's peer associations.";

	    list peer {
		key "id";

		leaf id {
		    type uint16;
		    description
			"The peer's association ID.";
		}

		container status {
		    description
			"The decoded peer status.";

		    leaf raw {
			type uint16;
			description
			    "The association's rw hex status value.";
		    }

		    leaf persistent {
			type boolean;
			description
			    "If true, the association condition is
			     persistent.";
		    }

		    leaf auth-enable {
			type boolean;
			description
			    "If true, authentication is enabled for
			     this association.";
		    }

		    leaf authentic {
			type boolean;
			description
			    "If true, the authetication is considered
			     okay for this association.";
		    }

		    leaf reachable {
			type boolean;
			description
			    "If true, the association is reachable.";
		    }

		    leaf broadcast {
			type boolean;
			description
			    "If true, this is a broadcast association.";
		    }

		    leaf selection {
			type ntp-selection;
			description
			    "One of the NTP peer selections rejected,
			     falsetick, excess, outlier, candidate,
			     backup, sys.peer, or pps.peer.";
		    }

		    leaf last-event {
			type ntp-event;
			description
			    "The most recent event received from this
			     peer.";
		    }

		    leaf event-count {
			type uint8 {
			    range "0..15";
			}
			description
			    "This is the number of peer exception
			     events that occurred since the last time
			     the peer event code changed.  Upon
			     reaching 15, subsequent events with the
			     same code are not counted.";
		    }
		}

		container variables {
		    description
			"The peer variables of an association.";

		    list variable {
			key "name";

			leaf name {
			    type string;
			    description
				"The name of the variable.  These are
				 named and described in the NTP RFCs.";
			}

			leaf raw {
			    type string;
			    description
				"The raw value returned from the peer.";
			}

			leaf decoded {
			    type string;
			    description
				"If needed, the raw value might be decoded
				 into something more legible.";
			}
		    }	
		}
	    }
	}
    }


    rpc ntp-control {
	input {
	    leaf operation {
		type ngcom:service-operation;
		mandatory true;
		description
		    "One of the strings 'start', 'stop', 'restart',
		     or 'status'.";
	    }

	    leaf namespace {
		type ngcom:network-namespace;
		description
		    "Network namespace.";
	    }
	}
	output {
	    leaf stdout {
		type string;
	    }
	}
    }

    rpc ntp-coredump {
	input {
	    leaf operation {
		type ngcom:service-op-enable-disable;
		mandatory true;
		description
		    "One of the strings 'enable', or 'disable'.";
	    }

	    leaf namespace {
		type ngcom:network-namespace;
		description
		    "Network namespace.";
	    }
	}
	output {
	    leaf stdout {
		type string;
	    }
	}
    }

    rpc ntp-config-operation {
	input {
	    leaf request {
		type string;
		description
		    "The operation, 'get-config-file'.";
	    }
	    leaf param {
		type string;
		description
		    "An optional parameter.";
	    }
	}
	output {
	    leaf stdout {
		type string;
	    }
	}
    }
}