Pozdrav svima. Danas ću govoriti o tome kako napisati svoj jednostavni NTP klijent. Uglavnom ćemo razgovarati o strukturi paketa i načinu obrade odgovora sa NTP servera. Kod će biti napisan u Pythonu, jer mislim da jednostavno nema boljeg jezika za ovakve stvari. Poznavatelji će primijetiti sličnost koda s kodom ntplib — upravo sam se time "inspirisao".
Dakle, šta je zapravo NTP? NTP – protokol za interakciju sa serverima tačnog vremena. Ovaj protokol se koristi na mnogim modernim mašinama. Na primjer, usluga w32tm u Windows-u.
Postoji ukupno 5 verzija NTP protokola. Prva, 0. verzija (1985, RFC958), trenutno se smatra zastarjelom. Sada se koriste novije verzije, 1. (1988, RFC1059), 2. (1989, RFC1119), 3. (1992, RFC1305) i 4. (1996, RFC2030). Verzije 1-4 su međusobno kompatibilne, razlikuju se samo po algoritmima rada. servera.
Format paketa

Leap indicator (indikator korekcije) – broj koji pokazuje upozorenje o sekundi korekcije. Vrijednost:
- 0 – nema korekcije
- 1 – posljednja minuta dana sadrži 61 sekundu
- 2 – posljednja minuta dana sadrži 59 sekundi
- 3 – kvar servera (vrijeme nije usklađeno)
Version number (broj verzije) – broj verzije NTP protokola (1-4).
Mode (mod) — režim rada pošiljaoca paketa. Vrijednost od 0 do 7, najčešće:
- 3 – klijent
- 4 – server
- 5 – širokofrekventni mod
Stratum (nivo slojevanja) – broj međuslojnih slojeva između servera i referentnog vremena (1 – server dobija podatke direktno od referentnih sati, 2 – server dobija podatke sa servera nivoa 1, itd.).
Pool – cijeli broj sa znakom, koji predstavlja maksimalni interval između uzastopnih poruka. NTP klijent ovdje navodi interval sa kojim planira da ispituje server, a NTP server – interval sa kojim planira da budu ispitan. Vrijednost je jednaka binarnom logaritmu sekundi.
Precision (preciznost) — cijeli broj sa znakom, koji predstavlja preciznost sistemskog sata. Vrijednost je jednaka binarnom logaritmu sekundi.
Root delay (kašnjenje servera) – vrijeme potrebno da podaci sa sata dođu do NTP servera, izraženo kao broj sekundi sa fiksnom tačkom.
Root dispersion (raspršenje očitavanja servera) — raspršenje očitavanja vremena NTP servera kao broj sekundi sa fiksnom tačkom.
Ref id (identifikator izvora) – id sati. Ako server ima stratum 1, ref id je naziv atomskih sati (4 ASCII znakova). Ako server koristi drugi server, adresa tog servera je zapisana u ref id.
Posljednja 4 polja predstavljaju vrijeme – 32 bita – cjeloviti dio, 32 bita – decimalni dio.
Referenca — posljednja očitavanja sati na serveru.
Porijeklo – vrijeme kada je paket poslan (popunjava ga server – o tome u nastavku).
Prijem – vrijeme prijema paketa od strane servera.
Prijenos – vrijeme slanja paketa sa servera klijentu (popunjava ga klijent, o tome također u nastavku).
Zadnja dva polja nećemo razmatrati.
Napišimo naš paket:
Kod paketa
class NTPPacket:
_FORMAT = "!B B b b 11I"
def __init__(self, version_number=2, mode=3, transmit=0):
# Neophodno za unos skoka sekunde (2 bita)
self.leap_indicator = 0
# Verzija protokola (3 bita)
self.version_number = version_number
# Način pošiljaoca (3 bita)
self.mode = mode
# Nivo "slojnosti" očitavanja vremena (1 bajt)
self.stratum = 0
# Interval između zahtjeva (1 bajt)
self.pool = 0
# Preciznost (log2) (1 bajt)
self.precision = 0
# Interval za pristup NTP serveru (4 bajta)
self.root_delay = 0
# Raspršenost sata NTP-servera (4 bajta)
self.root_dispersion = 0
# Indikator satova (4 bajta)
self.ref_id = 0
# Posljednje ažurirano vrijeme na serveru (8 bajtova)
self.reference = 0
# Vrijeme slanja paketa sa lokalnog računara (8 bajtova)
self.originate = 0
# Vrijeme prijema na serveru (8 bajtova)
self.receive = 0
# Vrijeme slanja odgovora sa servera (8 bajtova)
self.transmit = transmit
Da bismo slali (i primali) paket na server, moramo znati kako ga pretvoriti u niz bajtova.
Za ovu (i obratnu) operaciju napisat ćemo dvije funkcije — pack() i unpack():
Funkcija 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))
Funkcija 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
Za lijene, kao dodatak – kod koji pretvara paket u lijepu stringu
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)
Slanje paketa na server
Na server je potrebno poslati paket sa popunjenim poljima Verzija, Mode i Prijenos. U Prijenos potrebno je navesti trenutno vreme na lokalnoj mašini (broj sekundi od 1. januara 1900. godine), verzija – bilo koja od 1-4, režim – 3 (režim klijenta).
Server, koji je primio zahtev, popunjava u NTP paketu sva polja, prekopirajući u polje Porijeklo vrijednost iz Prijenos, koja je stigla u zahtevu. Za mene je zagonetka zašto klijent ne može odmah popuniti vrednost svog vremena u polju Porijeklo. Na kraju, kada paket stigne nazad, klijent ima 4 vrednosti vremena – vreme slanja zahteva (Porijeklo), vreme prijema zahteva od strane servera (Prijem), vreme slanja odgovora sa servera (Prijenos) i vreme prijema odgovora od klijenta – Stigne (nije u paketu). Uz pomoć ovih vrednosti možemo utvrditi tačno vreme.
Kod slanja i primanja paketa
# 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)
Obrada podataka sa servera
Obrada podataka s poslužitelja slična je postupcima engleskog džentlmena iz stare zagonetke Raymonda M. Smalleyana (1978): „Jednom čovjeku nije bilo pametnog sata, ali je kod kuće visio točan zidni sat koji je ponekad zaboravljao navijati. Jednom, zaboravivši još jednom naviti sat, otišao je kod prijatelja, proveo večer kod njega, a kada se vratio kući, uspio je ispravno namjestiti sat. Kako mu je to pošlo za rukom, kada vreme putovanja unaprijed nije bilo poznato?“ Odgovor je sljedeći: „Izašavši iz kuće, čovjek navije sat i pamti u kojem su položaju kazaljke. Kada dođe kod prijatelja i odlazi od njega, bilježi vrijeme svog dolaska i odlaska. To mu omogućava da sazna koliko je dugo bio kod prijatelja. Vraćajući se kući i pogledajući na sat, čovjek određuje trajanje svog odsustva. Oduzimajući od tog vremena ono što je proveo kod prijatelja, saznaje vrijeme utrošeno na putu do tamo i nazad. Dodajući pola vremena utrošenog na put do vremenu izlaska iz posjeta, dobiva mogućnost da sazna vrijeme dolaska kući i odgovarajuće prilagodi kazaljke svog sata.
Pronađimo vrijeme obrade poslužitelja za zahtjev:
- Pronađimo vrijeme putovanja paketa od klijenta do poslužitelja: ((Arrive – Originate) — (Transmit – Receive)) / 2
- Pronađimo razliku između vremena klijenta i poslužitelja:
Receive — Originate — ((Arrive – Originate) — (Transmit – Receive)) / 2 =
2 * Receive — 2 * Originate – Arrive + Originate + Transmit – Receive =
Receive – Originate – Arrive + Transmit
Dodajemo dobivenu vrijednost lokalnom vremenu i uživamo u životu.
Ispis rezultata
time_different = answer.get_time_different(arrive_time)
result = "Razlika u vremenu: {}nVrijeme poslužitelja: {}n{}".format(
time_different,
datetime.datetime.fromtimestamp(time.time() + time_different).strftime("%c"),
answer.to_display())
print(result)
Korisno .
Izvor: habr.com
