<h2>Edit File: ntpdig</h2><form method="post"><textarea name="content" rows="20" cols="80">#! /usr/bin/python3 -s
# -*- coding: utf-8 -*-
&quot;&quot;&quot;
ntpdig - simple SNTP client

&quot;&quot;&quot;
# SPDX-License-Identifier: BSD-2-Clause
# This code runs identically under Python 2 and Python 3. Keep it that way!
from __future__ import print_function, division
import getopt
import math
import select
import socket
import sys
import time

try:
    import ntp.magic
    import ntp.packet
    import ntp.util
except ImportError as e:
    sys.stderr.write(
        &quot;ntpdig: can&#039;t find Python NTP library -- check PYTHONPATH.\n&quot;)
    sys.stderr.write(&quot;%s\n&quot; % e)
    sys.exit(1)
# This code is somewhat stripped down from the legacy C version.  It
# does however have one additional major feature; it can filter
# out falsetickers from multiple samples, like the ntpdate of old,
# rather than just taking the first reply it gets.
#
# Listening to broadcast addresses is not implemented because that is
# impossible to secure. KOD recording is also not implemented, as it
# can too easily be spammed.  Thus, the options -b and -K are not
# implemented.
#
# There are no version 3 NTP servers left, so the -o version for setting
# NTP version has been omitted.
#
# Because ntpdig doesn&#039;t use symmetric-peer mode (it never did, and NTPsec has
# abolished that mode because it was a security hazard), there&#039;s no need to
# set the packet source port, so -r/--usereservedport has been dropped.
# If this option ever needs to be reinstated, the magic is described here:
# http://stackoverflow.com/questions/2694212/socket-set-source-port-number
# and would be s.bind((&#039;&#039;, 123)) right after the socket creation.
#
# The -w/--wait and -W/--nowait options only made sense with asynchronous
# DNS.  Asynchronous DNS was absurd overkill for this application, we are
# not looking up 20,000 hosts here.  It has not been implemented, so neither
# have these options.
#
# Finally, logging to syslog by default was a design error, violating
# Unix principles, that has been fixed. To get this behavior when
# running in a script, redirect standard error to logger(1).
#
# The one new option in this version is -p, borrowed from ntpdate.


def read_append(s, packets, packet, sockaddr):
    d, a = s.recvfrom(1024)
    if debug &gt;= 2:
        ntp.packet.dump_hex_printable(d)
    if credentials:
        if not ntp.packet.Authenticator.have_mac(d):
            if debug:
                log(&quot;no MAC on reply from %s&quot; % packet.hostname)
        if not credentials.verify_mac(d, packet_end=48, mac_begin=48):
            packet.trusted = False
            log(&quot;MAC verification on reply from %s failed&quot;
                % sockaddr[0])
        elif debug:
            log(&quot;MAC verification on reply from %s succeeded&quot;
                % sockaddr[0])
    pkt = ntp.packet.SyncPacket(d)
    pkt.hostname = server
    pkt.resolved = sockaddr[0]
    packets.append(pkt)
    return packets


def queryhost(server, concurrent, timeout=5, port=123):
    &quot;Query IP addresses associated with a specified host.&quot;
    try:
        iptuples = socket.getaddrinfo(server, port,
                                      af, socket.SOCK_DGRAM,
                                      socket.IPPROTO_UDP)
    except socket.gaierror as e:
        log(&quot;lookup of %s failed, errno %d = %s&quot; % (server, e.args[0], e.args[1]))
        return []
    sockets = []
    packets = []
    request = ntp.packet.SyncPacket()
    request.transmit_timestamp = ntp.packet.SyncPacket.posix_to_ntp(
        time.time())
    packet = request.flatten()
    needgap = (len(iptuples) &gt; 1) and (gap &gt; 0)
    firstloop = True
    for (family, socktype, proto, canonname, sockaddr) in iptuples:
        if needgap and not firstloop:
            time.sleep(gap)
        if firstloop:
            firstloop = False
        if debug:
            log(&quot;querying %s (%s)&quot; % (sockaddr[0], server))
        s = socket.socket(family, socktype)
        if keyid and keytype and passwd:
            if debug:
                log(&quot;authenticating with %s key %d&quot; % (keytype, keyid))
            mac = ntp.packet.Authenticator.compute_mac(packet,
                                                       keyid, keytype, passwd)
            if mac is None:
                log(&quot;MAC generation failed while querying %s&quot; % server)
                raise SystemExit(1)
            else:
                packet += mac
        try:
            s.sendto(packet, sockaddr)
        except socket.error as e:
            if debug:
                log(&quot;socket error on transmission: %s&quot; % e)
            continue
        if debug &gt;= 2:
            log(&quot;Sent to %s:&quot; % (sockaddr[0],))
            ntp.packet.dump_hex_printable(packet)
        if concurrent:
            sockets.append(s)
        else:
            r, _, _ = select.select([s], [], [], timeout)
            if r:
                read_append(s, packets, packet, sockaddr)
        while sockets:
            r, _, _ = select.select(sockets, [], [], timeout)
            if not r:
                return packets
            for s in sockets:
                read_append(s, packets, packet, sockaddr)
                sockets.remove(s)
    return packets


def clock_select(packets):
    &quot;Select the pick-of-the-litter clock from the samples we&#039;ve got.&quot;
    # This is a slightly simplified version of the filter ntpdate used
    NTP_INFIN = 15          # max stratum, infinity a la Bellman-Ford

    # This first chunk of code is supposed to go through all
    # servers we know about to find the servers that
    # are most likely to succeed. We run through the list
    # doing the sanity checks and trying to insert anyone who
    # looks okay. We are at all times aware that we should
    # only keep samples from the top two strata.
    #
    filtered = []
    for response in packets:
        def drop(msg):
            log(&quot;%s: Response dropped: %s&quot; % (response.hostname, msg))
        if response.stratum &gt; NTP_INFIN:
            drop(&quot;stratum too high&quot;)
            continue
        if response.version() &lt; ntp.magic.NTP_OLDVERSION:
            drop(&quot;response version %d is too old&quot; % response.version())
            continue
        if response.mode() != ntp.magic.MODE_SERVER:
            drop(&quot;unexpected response mode %d&quot; % response.mode())
            continue
        if response.version() &gt; ntp.magic.NTP_VERSION:
            drop(&quot;response version %d is too new&quot; % response.version())
            continue
        if response.stratum == 0:
            # FIXME: Do some kind of semi-useful diagnostic dump here
            drop(&quot;stratum 0, probable KOD packet&quot;)
            continue
        if response.leap() == &quot;unsync&quot;:
            drop(&quot;leap not in sync&quot;)
            continue
        if not response.trusted:
            drop(&quot;request was authenticated but server is untrusted&quot;)
            continue
        # Bypass this test if we ever support broadcast-client mode again
        if response.origin_timestamp == 0:
            drop(&quot;unexpected response timestamp&quot;)
            continue
        filtered.append(response)

    if len(filtered) &lt;= 1:
        return filtered

    # Sort by stratum and other figures of merit
    filtered.sort(key=lambda s: (s.stratum, s.synchd(), s.root_delay))

    # Return the best
    return filtered[:1]


def report(packet, json):
    &quot;Report on the SNTP packet selected for display, and its adjustment.&quot;
    say = sys.stdout.write

    packet.posixize()

    # The server&#039;s idea of the time
    t = time.localtime(int(packet.transmit_timestamp))
    ms = int(packet.transmit_timestamp * 1000000) % 1000000

    if t.tm_isdst:
        tmoffset = -time.altzone // 60  # In minutes
    else:
        tmoffset = -time.timezone // 60  # In minutes

    # Number of decimal digits of precision indicated by the precision field
    digits = min(6, -int(math.log10(2**packet.precision)))

    date = time.strftime(&quot;%Y-%m-%d&quot;, t)
    tod = time.strftime(&quot;%T&quot;, t) + (&quot;.%-*d&quot; % (digits, ms)).rstrip()
    sgn = (&quot;%+d&quot; % tmoffset)[0]
    tz = &quot;%s%02d%02d&quot; % (sgn, abs(tmoffset) // 60, tmoffset % 60)

    if json:
        say(&#039;{&quot;time&quot;:&quot;%sT%s%s&quot;,&quot;offset&quot;:%f,&quot;precision&quot;:%f,&quot;host&quot;:&quot;%s&quot;,&#039;
            &#039;&quot;ip&quot;:&quot;%s&quot;,&quot;stratum&quot;:%s,&quot;leap&quot;:&quot;%s&quot;,&quot;adjusted&quot;:%s}\n&#039;
            % (date, tod, tz,
               packet.adjust(), packet.synchd(),
               packet.hostname, packet.resolved or packet.hostname,
               packet.stratum, packet.leap(),
               &quot;true&quot; if adjusted else &quot;false&quot;))
    else:
        say(&quot;%s %s (%s) %+f +/- %f %s&quot;
            % (date, tod, tz,
               packet.adjust(), packet.synchd(),
               packet.hostname))
        if packet.resolved and packet.resolved != packet.hostname:
            say(&quot; &quot; + packet.resolved)
        say(&quot; s%d %s\n&quot; % (packet.stratum, packet.leap()))


usage = &quot;&quot;&quot;
USAGE:  ntpdig [-&lt;flag&gt; [&lt;val&gt;] | --&lt;name&gt;[{=| }&lt;val&gt;]]...
                [ hostname-or-IP ...]
  Flg Arg Option-Name     Description
   -4 no  ipv4           Force IPv4 DNS name resolution
                                - prohibits the option &#039;ipv6&#039;
   -6 no  ipv6           Force IPv6 DNS name resolution
                                - prohibits the option &#039;ipv4&#039;
   -a Num authentication  Enable authentication with the numbered key
   -c yes concurrent      Hosts to be queried concurrently
   -d no  debug           Increase debug verbosity
   -D yes set-debug-level Set debug verbosity
   -g yes gap             Set gap between requests in milliseconds
   -j no  json            Use JSON output format
   -l Str logfile         Log to specified logfile
                                 - prohibits the option &#039;syslog&#039;
   -p yes samples         Number of samples to take (default 1)
   -S no  step            Set (step) the time with clock_settime()
                                 - prohibits the option &#039;step&#039;
   -s no  slew            Set (slew) the time with adjtime()
                                 - prohibits the option &#039;slew&#039;
   -t Num timeout         Request timeout in seconds (default 5)
   -k Str keyfile         Specify a keyfile. ntpdig will look in this file
                          for the key specified with -a
   -V no version          Output version information and exit
   -h no  help            Display extended usage information and exit
&quot;&quot;&quot;


if __name__ == &#039;__main__&#039;:
    bin_ver = &quot;ntpsec-1.2.2a&quot;
    if ntp.util.stdversion() != bin_ver:
        sys.stderr.write(&quot;Module/Binary version mismatch\n&quot;)
        sys.stderr.write(&quot;Binary: %s\n&quot; % bin_ver)
        sys.stderr.write(&quot;Module: %s\n&quot; % ntp.util.stdversion())
    try:
        try:
            (options, arguments) = getopt.getopt(
                sys.argv[1:],
                &quot;46a:c:dD:g:hjk:l:M:o:p:r:Sst:wWV&quot;,
                [&quot;ipv4&quot;, &quot;ipv6&quot;,
                 &quot;authentication=&quot;,
                 &quot;concurrent=&quot;,
                 &quot;gap=&quot;, &quot;help&quot;, &quot;json&quot;,
                 &quot;keyfile=&quot;, &quot;logfile=&quot;,
                 &quot;replay=&quot;,
                 &quot;samples=&quot;, &quot;steplimit=&quot;,
                 &quot;step&quot;, &quot;slew&quot;,
                 &quot;timeout=&quot;,
                 &quot;debug&quot;, &quot;set-debug-level=&quot;,
                 &quot;version&quot;])
        except getopt.GetoptError as e:
            print(e)
            raise SystemExit(1)
        progname = sys.argv[0]

        logfp = sys.stderr
        log = lambda m: logfp.write(&quot;ntpdig: %s\n&quot; % m)

        af = socket.AF_UNSPEC
        authkey = None
        concurrent_hosts = []
        debug = 0
        gap = .05
        json = False
        keyfile = None
        steplimit = 0       # Default is intentionally zero
        samples = 1
        step = False
        slew = False
        timeout = 5
        replay = None
        try:
            for (switch, val) in options:
                if switch in (&quot;-4&quot;, &quot;--ipv4&quot;):
                    af = socket.AF_INET
                elif switch in (&quot;-6&quot;, &quot;--ipv6&quot;):
                    af = socket.AF_INET6
                elif switch in (&quot;-a&quot;, &quot;--authentication&quot;):
                    errmsg = &quot;Error: -a parameter &#039;%s&#039; not a number\n&quot;
                    authkey = ntp.util.safeargcast(val, int, errmsg, usage)
                elif switch in (&quot;-c&quot;, &quot;--concurrent&quot;):
                    concurrent_hosts.append(val)
                elif switch in (&quot;-d&quot;, &quot;--debug&quot;):
                    debug += 1
                elif switch in (&quot;-D&quot;, &quot;--set-debug-level&quot;):
                    errmsg = &quot;Error: -D parameter &#039;%s&#039; not a number\n&quot;
                    debug = ntp.util.safeargcast(val, int, errmsg, usage)
                elif switch in (&quot;-g&quot;, &quot;--gap&quot;):
                    errmsg = &quot;Error: -g parameter &#039;%s&#039; not a number\n&quot;
                    gap = ntp.util.safeargcast(val, int, errmsg, usage)
                elif switch in (&quot;-j&quot;, &quot;--json&quot;):
                    json = True
                elif switch in (&quot;-k&quot;, &quot;--keyfile&quot;):
                    keyfile = val
                elif switch in (&quot;-l&quot;, &quot;--logfile&quot;):
                    try:
                        logfp = open(val, &quot;w&quot;)
                    except OSError:
                        sys.stderr.write(&quot;logfile open of %s failed.\n&quot; % val)
                        raise SystemExit(1)
                elif switch in (&quot;-M&quot;, &quot;--steplimit&quot;):
                    errmsg = &quot;Error: -M parameter &#039;%s&#039; not a number\n&quot;
                    steplimit = ntp.util.safeargcast(val, int, errmsg, usage)
                    steplimit /= 1000.0
                elif switch in (&quot;-p&quot;, &quot;--samples&quot;):
                    errmsg = &quot;Error: -p parameter &#039;%s&#039; not a number\n&quot;
                    samples = ntp.util.safeargcast(val, int, errmsg, usage)
                    if samples &lt; 1:  # If &lt;1 it won&#039;t run at all
                        samples = 1
                elif switch in (&#039;-r&#039;, &quot;--replay&quot;):
                    replay = val
                elif switch in (&quot;-S&quot;, &quot;--step&quot;):
                    step = True
                elif switch in (&quot;-s&quot;, &quot;--slew&quot;):
                    slew = True
                elif switch in (&quot;-t&quot;, &quot;--timeout&quot;):
                    errmsg = &quot;Error: -t parameter &#039;%s&#039; not a number\n&quot;
                    timeout = ntp.util.safeargcast(val, int, errmsg, usage)
                elif switch in (&quot;-h&quot;, &quot;--help&quot;):
                    print(usage)
                    raise SystemExit(0)
                elif switch in (&quot;-V&quot;, &quot;--version&quot;):
                    print(&quot;ntpdig %s&quot; % bin_ver)
                    raise SystemExit(0)
                else:
                    sys.stderr.write(
                        &quot;Unknown command line switch or missing argument.\n&quot;)
                    sys.stderr.write(usage)
                    raise SystemExit(1)
        except ValueError:
            sys.stderr.write(&quot;Invalid argument.\n&quot;)
            sys.stderr.write(usage)
            raise SystemExit(1)

        gap /= 1000  # convert to milliseconds

        credentials = keyid = keytype = passwd = None
        try:
            credentials = ntp.packet.Authenticator(keyfile)
        except (OSError, IOError):
            sys.stderr.write(&quot;ntpdig: %s nonexistent or unreadable\n&quot; %
                             keyfile)
            raise SystemExit(1)
        if credentials:
            try:
                (keyid, keytype, passwd) = credentials.control(authkey)
            except ValueError:
                # There are no trusted keys.  Barf.
                log(&quot;cannot get authentication key&quot;)
                raise SystemExit(1)

        if not credentials and authkey and keyfile is None:
            sys.stderr.write(&quot;-a option requires -k.\n&quot;)
            raise SystemExit(1)

        if not arguments:
            arguments = [&quot;localhost&quot;]

        if replay:
            (pkt, dst) = replay.split(&quot;:&quot;)
            packet = ntp.packet.SyncPacket(pkt.decode(&quot;hex&quot;))
            packet.received = ntp.packet.SyncPacket.posix_to_ntp(float(dst))
            returned = [packet]
        else:
            returned = []
            needgap = (samples &gt; 1) and (gap &gt; 0)
            firstloop = True
            for s in range(samples):
                if needgap and not firstloop:
                    time.sleep(gap)
                if firstloop:
                    firstloop = False
                for server in concurrent_hosts:
                    try:
                        returned += queryhost(server=server,
                                              concurrent=True,
                                              timeout=timeout)
                    except ntp.packet.SyncException as e:
                        log(str(e))
                        continue
                for server in arguments:
                    try:
                        returned += queryhost(server=server,
                                              concurrent=False,
                                              timeout=timeout)
                    except ntp.packet.SyncException as e:
                        log(str(e))
                        continue

            returned = clock_select(returned)

        if returned:
            pkt = returned[0]
            if debug:
                # print(repr(pkt))
                def hexstamp(n):
                    return &quot;%08x.%08x&quot; % (n &gt;&gt; 32, n &amp; 0x00000000ffffffff)
                print(&quot;org t1: %s rec t2: %s&quot;
                      % (hexstamp(pkt.t1()), hexstamp(pkt.t2())))
                print(&quot;xmt t3: %s dst t4: %s&quot;
                      % (hexstamp(pkt.t3()), hexstamp(pkt.t4())))
            pkt.posixize()
            if debug:
                print(&quot;org t1: %f rec t2: %f&quot; % (pkt.t1(), pkt.t2()))
                print(&quot;xmt t3: %f dst t4: %f&quot; % (pkt.t3(), pkt.t4()))
                print(&quot;rec-org t21: %f  xmt-dst t34: %f&quot;
                      % (pkt.t2() - pkt.t1(), pkt.t3() - pkt.t4()))
            offset = pkt.adjust()
            adjusted = (step and
                        (not slew or (slew and (abs(offset) &gt; steplimit))))
            report(pkt, json)
            # If we can step but we cannot slew, then step.
            # If we can step or slew and |offset| &gt; steplimit, then step.
            rc = True
            ntp.ntpc.setprogname(&quot;ntpdig&quot;)
            if adjusted:
                rc = ntp.ntpc.step_systime(offset)
            elif slew:
                rc = ntp.ntpc.adj_systime(offset)
            if rc:
                raise SystemExit(0)
            else:
                raise SystemExit(1)
        else:
            log(&quot;no eligible servers&quot;)
            raise SystemExit(1)
    except KeyboardInterrupt:
        print(&quot;&quot;)

# end
</textarea><br><input type="hidden" name="edit_file" value="ntpdig"><input type="submit" value="Save"></form>