Здравствуйте, хабраюзеры. Сегодня я хочу рассказать о том, как написать свой простенький NTP клиент. В основном, разговор зайдет о структуре пакета и способе обработки ответа с NTP сервера. Код будет написан на питоне, потому что, как мне кажется, лучшего языка для подобных вещей просто не найти. Знатоки обратят внимание на схожесть кода с кодом ntplib — я «вдохновлялся» именно им.
Итак, что вообще такое NTP? NTP – протокол взаимодействия с серверами точного времени. Этот протокол используется во многих современных машинах. Например, служба w32tm в windows.
Всего существует 5 версий NTP протокола. Первая, 0-я версия (1985 г, RFC958)), в данный момент считается устаревшей. Сейчас используются более новые, 1-я (1988, RFC1059), 2-я(1989, RFC1119), 3-я(1992, RFC1305) и 4-я(1996, RFC2030). 1-4 версии являются совместимыми друг с другом, они отличаются лишь алгоритмами работы серверов.
Формат пакета
Leap indicator (индикатор коррекции) — число, показывающее предупреждение о секунде координации. Значение:
- 0 – нет коррекции
- 1 – последняя минута дня содержит 61 секунду
- 2 – последняя минута дня содержит 59 секунд
- 3 – неисправность сервера (время не синхронизировано)
Version number (номер версии) – номер версии протокола NTP (1-4).
Mode (режим) — режим работы отправителя пакета. Значение от 0 до 7, наиболее частые:
- 3 – клиент
- 4 – сервер
- 5 – широковещательный режим
Stratum (уровень наслоения) – количество промежуточных слоев между сервером и эталонными часами (1 – сервер берет данные непосредственно с эталонных часов, 2 – сервер берет данные с сервера с уровнем 1 и т.д.).
Pool — целое число со знаком, представляющее максимальный интервал между последовательными сообщениями. NTP-клиент указывает здесь интервал, с которым он предполагает опрашивать сервер, а NTP-сервер – интервал, с которым он предполагает, чтобы его опрашивали. Значение равно двоичному логарифму секунд.
Precision (точность) — целое число со знаком, представляющее точность системных часов. Значение равно двоичному логарифму секунд.
Root delay (задержка сервера) – время, за которое показания часов доходят до NTP-сервера, как число секунд с фиксированной точкой.
Root dispersion (разброс показаний сервера) — разброс показаний часов NTP-сервера как число секунд с фиксированной точкой.
Ref id (идентификатор источника) – id часов. Если сервер имеет стратум 1, то ref id – название атомных часов (4 ASCII символа). Если сервер использует другой сервер, то в ref id записан адрес этого сервера.
Последние 4 поля представляют из себя время – 32 бита – целая часть, 32 бита – дробная часть.
Reference — последние показания часов на сервере.
Originate – время, когда пакет был отправлен (заполняется сервером – об этом ниже).
Receive – время получения пакета сервером.
Transmit – время отправки пакета с сервера клиенту (заполняется клиентом, об этом тоже ниже).
Два последних поля рассматривать не будем.
Напишем наш пакет:
Код пакета
class NTPPacket:
_FORMAT = "!B B b b 11I"
def __init__(self, version_number=2, mode=3, transmit=0):
# Necessary of enter leap second (2 bits)
self.leap_indicator = 0
# Version of protocol (3 bits)
self.version_number = version_number
# Mode of sender (3 bits)
self.mode = mode
# The level of "layering" reading time (1 byte)
self.stratum = 0
# Interval between requests (1 byte)
self.pool = 0
# Precision (log2) (1 byte)
self.precision = 0
# Interval for the clock reach NTP server (4 bytes)
self.root_delay = 0
# Scatter the clock NTP-server (4 bytes)
self.root_dispersion = 0
# Indicator of clocks (4 bytes)
self.ref_id = 0
# Last update time on server (8 bytes)
self.reference = 0
# Time of sending packet from local machine (8 bytes)
self.originate = 0
# Time of receipt on server (8 bytes)
self.receive = 0
# Time of sending answer from server (8 bytes)
self.transmit = transmit
Чтобы слать (и принимать) пакет на сервер, мы должны уметь превращать его в массив байт.
Для этой (и обратной) операции напишем две функции — pack() и unpack():
Функция 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
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
Для лентяев, в качестве приложения – код, превращающий пакет в красивую строку
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)
Отправка пакета на сервер
На сервер необходимо отправить пакет с заполненными полями Version, Mode и Transmit. В Transmit необходимо указать текущее время на локальной машине (количество секунд с 1 января 1900 г), версия — любая из 1-4, режим — 3 (реижм клиента).
Сервер, приняв запрос, заполняет в NTP-пакете все поля, скопировав в поле Originate значение из Transmit, пришедшее в запросе. Для меня является загадкой, почему клиент не может сразу заполнить значение своего времени в поле Originate. В итоге, когда пакет приходит обратно, у клиента есть 4 значения времени – время отправки запроса (Originate), время получения запроса сервером (Receive), время отправки ответа сервером (Transmit) и время получения ответа клиентом – Arrive (нет в пакете). С помощью этих значений мы можем установить корректное время.
Код отправки и получения пакета
# 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)
Обработка данных с сервера
Обработка данных с сервера аналогична действиям английского джентльмена из старой задачи Рэймонда М. Смаллиана (1978): «У одного человека не было наручных часов, но зато дома висели точные настенные часы, которые он иногда забывал заводить. Однажды, забыв очередной раз завести часы, он отправился в гости к своему другу, провел у того вечер, а вернувшись домой, сумел правильно поставить часы. Каким образом ему удалось это сделать, если время в пути заранее известно не было?» Ответ таков: «Выходя из дома, человек заводит часы и запоминает, в каком положении находятся стрелки. Придя к другу и уходя из гостей, он отмечает время своего прихода и ухода. Это позволяет ему узнать, сколько он находился в гостях. Вернувшись домой и взглянув на часы, человек определяет продолжительность своего отсутствия. Вычитая из этого времени то время, которое он провел в гостях, человек узнает время, затраченное на дорогу туда и обратно. Прибавив ко времени выхода из гостей половину времени, затраченного на дорогу, он получает возможность узнать время прихода домой и перевести соответствующим образом стрелки своих часов.»
Находим время работы сервера над запросом:
- Находим время пути пакета от клиента к серверу: ((Arrive – Originate) — (Transmit – Receive)) / 2
- Находим разницу между временем клиента и сервера:
Receive — Originate — ((Arrive – Originate) — (Transmit – Receive)) / 2 =
2 * Receive — 2 * Originate – Arrive + Originate + Transmit – Receive =
Receive – Originate – Arrive + Transmit
Добавляем полученное значение к локальному времени и радуемся жизни.
Вывод результата
time_different = answer.get_time_different(arrive_time)
result = "Time difference: {}nServer time: {}n{}".format(
time_different,
datetime.datetime.fromtimestamp(time.time() + time_different).strftime("%c"),
answer.to_display())
print(result)
Полезная .
Источник: habr.com