Kirjutame lihtsa NTP kliendi

Tere, hääli kasutajad. Täna tahan rääkida sellest, kuidas kirjutada oma lihtne NTP klient. Peamiselt räägime paketi struktuurist ja sellest, kuidas töödelda vastust NTP serverilt. Kood kirjutatakse Pythoni keeles, sest nagu mulle tundub, ei leidu paremat keelt selliste asjaolude jaoks.

Nii, mis asi see NTP siis on? NTP – protokoll, mille kaudu suheldakse täpsusaja serveritega. Seda protokolli kasutatakse paljudes kaasaegsetes seadmetes. Näiteks w32tm teenus Windowsis.

Kokku on olemas 5 NTP protokolli versiooni. Esimene, nullandmeversioon (1985, RFC958), loetakse praegu vananenuks. Praegu kasutatakse uusi versioone: esimene (1988, RFC1059), teine (1989, RFC1119), kolmas (1992, RFC1305) ja neljas (1996, RFC2030). Esimene kuni neljas versioon on omavahel ühilduvad, need erinevad vaid töö algoritmide poolest. serverite.

Paketi formaat

Leap indicator (korrektsiooninäidik) – number, mis näitab hoiatussekundi koordinaate. Väärtus:

• 0 – ei ole korrektsiooni
• 1 – päeva viimane minut sisaldab 61 sekundi
• 2 – päeva viimane minut sisaldab 59 sekundi
• 3 – server fault (time not synchronized)

Versiooninumber (versiooninumber) – NTP-protokollan versioonin numero (1-4).

Režiim (režiim) — paketti saatavan lähettäjän toimintatila. Arvo 0-7, yleisimmät:

• 3 – asiakas
• 4 – palvelin
• 5 – laajennusrežiimi

Stratum (kerros) – välikerrosten määrä palvelimen ja vertailuaikojen välillä (1 – palvelin ottaa tiedot suoraan vertailuaikasilta, 2 – palvelin ottaa tiedot palvelimelta, jonka kerros on 1 jne.).
Pool — merkkiluku, joka edustaa suurinta väliä peräkkäisten viestien välillä. NTP-asiakas määrittelee tässä välin, jolla se aikoo kysyä palvelinta, ja NTP-palvelin – välin, jolla se odottaa kysyttävän. Arvo on sekuntien binaarilukujohdin.
Tarkkuus (tarkkuus) — merkkiluku, joka edustaa järjestelmäkellojen tarkkuutta. Arvo on sekuntien binaarilukujohdin.
Root-viive (palvelimen viive) – aika, jonka kuluessa kellojen näyttö saapuu NTP-palvelimelle, sekunteina kiinteällä pisteellä.
Root-hajonta (serveri näidud vahe) — NTP-serveri aja näitude vahe sekundites, fikseeritud punktiga.
Ref id (allika identifikaator) – kellade id. Kui serveril on stratum 1, siis ref id – aatomikellade nimetus (4 ASCII tähte). Kui server kasutab teist serverit, siis ref id-s on selle serveri aadress.
Viimased 4 väljad esindavad aega – 32 bitti – tervikosa, 32 bitti – murdosa.
Reference — viimased kella näidud serveris.
Originate – aeg, mil pakett saadeti (täidetakse serveri poolt – sellest räägime allpool).
Receive – aeg, mil server sai paketti.
Transmit – aeg, mil server saadab paketti kliendile (täidetakse kliendi poolt, sellest samuti allpool).

Kahte viimast väljad ei käsitle.

Kirjutame meie paketi:

Paketi kood

class NTPPacket:
    _FORMAT = "!B B b b 11I"

    def __init__(self, version_number=2, mode=3, transmit=0):
        # Üksikasjalik teave hüppe sekundi kohta (2 bitti)
        self.leap_indicator = 0
        # Protokolli versioon (3 bitti)
        self.version_number = version_number
        # Saatja režiim (3 bitti)
        self.mode = mode
        # "Kihilisuse" lugemise tase (1 bait)
        self.stratum = 0
        # Aja päringu vahe (1 bait)
        self.pool = 0
        # Täpsus (log2) (1 bait)
        self.precision = 0
        # Kella jõudmise vahe NTP serverisse (4 baiti)
        self.root_delay = 0
        # Kellade hajumine NTP-serveris (4 baiti)
        self.root_dispersion = 0
        # Kellade indikaator (4 baiti)
        self.ref_id = 0
        # Viimase uuenduse aeg serveris (8 baiti)
        self.reference = 0
        # Paketi saatmise aeg kohalikust masinast (8 baiti)
        self.originate = 0
        # Vastuvõtu aeg serveris (8 baiti)
        self.receive = 0
        # Vastuse saatmise aeg serverist (8 baiti)
        self.transmit = transmit

Et saata (ja vastu võtta) pakette serverile, peame oskama neid muuta baitide massiiviks.
Selle (ja tagasikäigu) operatsiooni jaoks kirjutame kaks funktsiooni — pack() ja unpack():

Funktsioon pack

def pack(self):
        return struct.pack(NTPPacket._FORMAT,
                (self.leap_indicator << 6) + 
                    (self.version_number << 3) + self.mode,
                self.stratum,
                self.pool,
                self.precision,
                int(self.root_delay) + get_fraction(self.root_delay, 16),
                int(self.root_dispersion) + 
                    get_fraction(self.root_dispersion, 16),
                self.ref_id,
                int(self.reference),
                get_fraction(self.reference, 32),
                int(self.originate),
                get_fraction(self.originate, 32),
                int(self.receive),
                get_fraction(self.receive, 32),
                int(self.transmit),
                get_fraction(self.transmit, 32))

Unpack funktsioon

def unpack(self, data: bytes):
        unpacked_data = struct.unpack(NTPPacket._FORMAT, data)

        self.leap_indicator = unpacked_data[0] >> 6  # 2 bits
        self.version_number = unpacked_data[0] >> 3 & 0b111  # 3 bits
        self.mode = unpacked_data[0] & 0b111  # 3 bits

        self.stratum = unpacked_data[1]  # 1 byte
        self.pool = unpacked_data[2]  # 1 byte
        self.precision = unpacked_data[3]  # 1 byte

        # 2 bytes | 2 bytes
        self.root_delay = (unpacked_data[4] >> 16) +
            (unpacked_data[4] & 0xFFFF) / 2 ** 16
         # 2 bytes | 2 bytes
        self.root_dispersion = (unpacked_data[5] >> 16) +
            (unpacked_data[5] & 0xFFFF) / 2 ** 16 

        # 4 bytes
        self.ref_id = str((unpacked_data[6] >> 24) & 0xFF) + " " + 
                      str((unpacked_data[6] >> 16) & 0xFF) + " " +  
                      str((unpacked_data[6] >> 8) & 0xFF) + " " +  
                      str(unpacked_data[6] & 0xFF)

        self.reference = unpacked_data[7] + unpacked_data[8] / 2 ** 32  # 8 bytes
        self.originate = unpacked_data[9] + unpacked_data[10] / 2 ** 32  # 8 bytes
        self.receive = unpacked_data[11] + unpacked_data[12] / 2 ** 32  # 8 bytes
        self.transmit = unpacked_data[13] + unpacked_data[14] / 2 ** 32  # 8 bytes

        return self

Laiskade jaoks, lisana – kood, mis muudab paketi ilusaks stringiks

def to_display(self):
        return "Leap indicator: {0.leap_indicator}n" 
                "Version number: {0.version_number}n" 
                "Mode: {0.mode}n" 
                "Stratum: {0.stratum}n" 
                "Pool: {0.pool}n" 
                "Precision: {0.precision}n" 
                "Root delay: {0.root_delay}n" 
                "Root dispersion: {0.root_dispersion}n" 
                "Ref id: {0.ref_id}n" 
                "Reference: {0.reference}n" 
                "Originate: {0.originate}n" 
                "Receive: {0.receive}n" 
                "Transmit: {0.transmit}"
                .format(self)

Paketi saatjale saatmine

Serverile tuleb saata paket, mille väljad on täidetud Versioon, Režiim ja Transmit. Dokumendihalduses Transmit on vajalik määrata kohalikul masinal praegune aeg (sekundid alates 1. jaanuarist 1900), versioon — ükskõik milline number vahemikus 1-4, režiim — 3 (klientide režiim).

Server, mis on päringu vastu võtnud, täidab NTP-paketis kõik väljad, kopeerides väljal Originate väärtuse Transmit, mis tuli päringus. On müsteerium, miks klient ei saa kohe oma aega välja täita. Originate. Lõpuks, kui pakett tagasi jõuab, on kliendil 4 ajaväärtust – päringu saatmise aeg (Originate), serveri päringu vastuvõtmise aeg (Receive), serveri vastuse saatmise aeg (Transmit) ja vastuse vastuvõtmise aeg kliendi poolt – Saabumine (paketis ei ole). Nende väärtuste abil saame määrata õige aja.

Paketi saatmine ja vastuvõtmine

# Time difference between 1970 and 1900, seconds
FORMAT_DIFF = (datetime.date(1970, 1, 1) - datetime.date(1900, 1, 1)).days * 24 * 3600
# Waiting time for recv (seconds)
WAITING_TIME = 5
server = "pool.ntp.org"
port = 123
    
packet = NTPPacket(version_number=2, mode=3, transmit=time.time() + FORMAT_DIFF)
answer = NTPPacket()
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
    s.settimeout(WAITING_TIME)
    s.sendto(packet.pack(), (server, port))
    data = s.recv(48)
    arrive_time = time.time() + FORMAT_DIFF
    answer.unpack(data)

Andmete töötlemine serverist

Andmete töötlemine serverist sarnaneb inglise mehe tegevustega Raymond M. Smullyani vanast ülesandest (1978): "Ühel mehel ei olnud randme kellasid, kuid kodus olid täpsed seinakellad, mida ta mõnikord unustas üles kerida. Ükskord, unustades jälle kella üles kerida, läks ta sõbra külla, veetis seal õhtu ja naastes koju, suutis ta kella õigesti seadistada. Kuidas tal see õnnestus, kui reisi aeg polnud ette teada?" Vastus on järgmine: "Kodust lahkudes keerab mees kella üles ja mäletab, millises asendis on käed. Külla jõudes ja seal olles märkab ta, millal ta tuli ja lahkus. See aitab tal teada, kui kaua ta külas viibis. Kodus tagasi ja kella vaadates määrab mees oma puudumise kestuse. Lahutades sellest ajast selle, mille ta veetis külaskäigus, saab ta teada, kui kaua kulus teekonnale kokku. Lisades külaskäigust lahkumise ajale poole tee läbimise aega, suudab ta kindlaks määrata kodus saabumise aja ja vastavalt sellele oma kella käed seadistada."

Otsime serveri tööaega päringu osas:

1. Otsime paketi teekonna aega kliendist serverisse: ((Saabumine – Algus) — (Edastamine – Vastuvõtt)) / 2
2. Otsime erinevust kliendi ja serveri vahel:
   Vastuvõtt — Algus — ((Saabumine – Algus) — (Edastamine – Vastuvõtt)) / 2 =
   2 * Vastuvõtt — 2 * Algus – Saabumine + Algus + Edastamine – Vastuvõtt =
   Vastuvõtt – Algus – Saabumine + Edastamine

Lisame saadud väärtuse kohalikule ajale ja naudime elu.

Tulemuse väljund

time_different = answer.get_time_different(arrive_time)
result = "Ajavahe: {}nServeri aeg: {}n{}".format(
    time_different,
    datetime.datetime.fromtimestamp(time.time() + time_different).strftime("%c"),
    answer.to_display())
print(result)

Kasulik link.

Allikas: habr.com