Kirjutame lihtsa NTP kliendi

Tere, Habr kasutajad. Täna tahan rääkida, kuidas kirjutada oma lihtne NTP klient. Peamiselt räägime paketi struktuurist ja vastuse töötlemise viisist NTP serverilt. Kood kirjutatakse Pythonis, sest minu arvates ei leia selliste asjade jaoks paremat keelt. Teadjad panevad tähele, et kood sarnaneb ntplib koodiga — ma olen just sellest "inspireeritud".

Nii, mis asi on NTP? NTP on protokoll, mis suhtleb täpsusaja serveritega. Seda protokolli kasutatakse paljudes kaasaegsetes masinates. Näiteks, teenus w32tm Windowsis.

Kokku on olemas 5 NTP protokolli versiooni. Esimene, 0. versioon (1985, RFC958), loetakse praegu aegunuks. Praegu kasutatakse uuemaid versioone: 1. (1988, RFC1059), 2. (1989, RFC1119), 3. (1992, RFC1305) ja 4. (1996, RFC2030). Versioonid 1-4 on omavahel ühilduvad, need erinevad vaid tööalgoritmide poolest. serverid.

Paketi formaat

Leap indicator (korrektsiooni indikaator) — number, mis näitab koordineeritud tunni hoiatust. Väärtus:

• 0 – korrektsiooni ei ole
• 1 – päeva viimane minut sisaldab 61 sekundit
• 2 – päeva viimane minut sisaldab 59 sekundit
• 3 – serveri rike (aeg ei ole sünkroniseeritud)

Version number (versiooninumber) – NTP protokolli versiooninumber (1-4).

Mode (režiim) — paketi saatja töörežiim. Väärtused 0 kuni 7, kõige sagedasemad:

• 3 – klient
• 4 – server
• 5 – laialdane režiim

Stratum (kihistumise tase) – kihi vahemaa arv serveri ja viidatud kellade vahel (1 – server võtab andmeid vahetult viidatud kelladelt, 2 – server võtab andmeid 1. taseme serverilt jne).
Pool — märgitud täisarv, mis esindab maksimaalset intervalli järjestikuste sõnumite vahel. NTP klient määrab siin intervalli, millest ta eeldab serveri küsitlemist, ning NTP server määrab intervalli, milles ta eeldab, et teda küsitakse. Väärtus on võrdne sekundite binaarse logaritmi väärtusega.
Precision (täpsus) — märgitud täisarv, mis esindab süsteemi kellade täpsust. Väärtus on sekundite binaarse logaritmi väärtus.
Root delay (serveri viivitus) – aeg, mille jooksul kellade näidud jõuavad NTP serverisse, fixed-point sekundi arvuna.
Root dispersion (serveri näitude hajumine) — NTP serveri kellade näitude hajumine fixed-point sekundi arvuna.
Ref id (allika identifikaator) – id kella. Kui serveril on stratum 1, siis ref id – aatomkellade nimi (4 ASCII märki). Kui server kasutab teist serverit, siis ref id-s on selles serveris asukoht.
Viimased 4 väljad tähendavad aega – 32 bitti – täisarv, 32 bitti – murdarv.
Viitega — serveri viimased kella näidud.
Algus – aeg, mil pakett saadeti (täidetakse serveri poolt – sellest allpool).
Saada – aeg, mil server pakketi sai.
Edastamine – aeg, mil pakett serverist kliendile saadeti (täidetakse kliendi poolt, sellest ka allpool).

Kahte viimast välja me 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):
        # Vajalik leap second (2 bitti)
        self.leap_indicator = 0
        # Protokolli versioon (3 bitti)
        self.version_number = version_number
        # Saaja režiim (3 bitti)
        self.mode = mode
        # Kihi „kihtimise” taseme lugemine (1 bait)
        self.stratum = 0
        # Taotluste vahe (1 bait)
        self.pool = 0
        # Täpsus (log2) (1 bait)
        self.precision = 0
        # Aeg, mis on vajalik NTP serveri juurde jõudmiseks (4 baiti)
        self.root_delay = 0
        # NTP-serveri kella hajutamine (4 baiti)
        self.root_dispersion = 0
        # Kellade indikaator (4 baiti)
        self.ref_id = 0
        # Viimane uuendamise aeg serveris (8 baiti)
        self.reference = 0
        # Aeg, mil pakett saadetakse kohalikult masinalt (8 baiti)
        self.originate = 0
        # Aeg, mil server paketi sai (8 baiti)
        self.receive = 0
        # Aeg, mil vastus serverist saadeti (8 baiti)
        self.transmit = transmit

Pakketi saatmiseks (ja vastuvõtmiseks) peame oskama seda massiiviks transformeerida.
Selle (ja tagasitee) toimingu 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))

Funktsioon unpack

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, rakenduse vormis – 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 saatmine serverisse

Serverisse tuleb saata pakett, mille väljad on täidetud Version, Mode ja Edastamine. Failis Edastamine on vajalik märkida kohaliku masina praegune kellaaeg (sekundite arv alates 1. jaanuarist 1900), versioon – ükskõik milline vahemik 1-4, režiim – 3 (kliendi režiim).

Server, kes saab nõude, täidab NTP-paketis kõik väljad, kopeerides välja Algus vaärtuse, mis tuli Edastamine, mis saabus nõudes. Minu jaoks on mõistatus, miks klient ei saa kohe täita oma aja väärtust väljale Algus. Lõppkokkuvõttes, kui pakett tagasi tuleb, on kliendil 4 ajaväärtust – nõude saatmise aeg (Algus), serveri poolt nõude saamise aeg (Saada), serveri poolt vastuse saatmise aeg (Edastamine) ja vastuse saabumise aeg kliendile – Saabub (paketis pole). Nende väärtuste abil saame määrata õige aja.

Paketist saatmise ja vastuvõtmise kood

# 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 on sarnane inglise härrasmehe tegudele Raymond M. Smullyani vanas ülesandes (1978): „Ühel inimesel ei olnud käekella, kuid kodus riputas täpne seinakell, mille ta mõnikord unustas maha keerata. Ühel päeval, unustades jälle kella maha keerata, läks ta sõbra juurde külla, veetis seal õhtu ja tagasi koju tulles suutis ta kella õigesti seadistada. Kuidas ta seda tegi, kui tee pikkus ei olnud ette teada?” Vastus on: „Väljudes kodust, keerab inimene kella üles ja mäletab, millises asendis on käed. Sõbra juures olles ja külast lahkudes märkab ta oma saabumise ja lahkumise kellaaegu. See võimaldab tal teada, kui kaua ta külas oli. Tagasi koju jõudes ja kellale vaadates, määrab ta oma puudumise kestuse. Lahutades sellest ajast külas oldud aja, saab ta teada, kui kaua kulus teekonnale edasi ja tagasi. Lisades lahkumise ajale poole teekonna kestusest, saab ta teada, millal koju jõudis, ja saab oma kella vastavalt seadistada.”

Leidke serveri tööaeg päringu jaoks:

1. Leidke paketi teekonna aeg kliendi ja serveri vahel: ((Saabumine – Algus) — (Edastus – Vastuvõtt)) / 2
2. Leidke erinevus kliendi ja serveri aja vahel:
   Vastuvõtt — Algus — ((Saabumine – Algus) — (Edastus – Vastuvõtt)) / 2 =
   2 * Vastuvõtt — 2 * Algus – Saabumine + Algus + Edastus – Vastuvõtt =
   Vastuvõtt – Algus – Saabumine + Edastus

Lisame saadud väärtuse kohalikku aega ja naudime elu.

Tulemuse väljastamine

time_different = answer.get_time_different(arrive_time)
result = "Aja erinevus: {}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