ການຂຽນລູກຄ້າ NTP ງ່າຍໆ

ສະບາຍດີ, Habrusers. ມື້​ນີ້​ຂ້າ​ພະ​ເຈົ້າ​ຕ້ອງ​ການ​ສົນ​ທະ​ນາ​ກ່ຽວ​ກັບ​ວິ​ທີ​ການ​ຂຽນ​ລູກ​ຄ້າ NTP ງ່າຍ​ດາຍ​ຂອງ​ທ່ານ​ເອງ​. ໂດຍພື້ນຖານແລ້ວ, ການສົນທະນາຈະຫັນໄປຫາໂຄງສ້າງຂອງແພັກເກັດແລະວິທີການປະມວນຜົນການຕອບສະຫນອງຈາກເຄື່ອງແມ່ຂ່າຍ NTP. ລະຫັດຈະຖືກຂຽນໃນ Python, ເພາະວ່າມັນເບິ່ງຄືວ່າຂ້ອຍບໍ່ມີພາສາທີ່ດີກວ່າສໍາລັບສິ່ງດັ່ງກ່າວ. Connoisseurs ຈະສັງເກດເຫັນຄວາມຄ້າຍຄືກັນຂອງລະຫັດທີ່ມີລະຫັດ ntplib - ຂ້ອຍໄດ້ຮັບການ "ດົນໃຈ" ຈາກມັນ.

ດັ່ງນັ້ນ NTP ແມ່ນຫຍັງ? NTP ແມ່ນໂປໂຕຄອນສໍາລັບການໂຕ້ຕອບກັບເຄື່ອງແມ່ຂ່າຍທີ່ໃຊ້ເວລາທີ່ແນ່ນອນ. ໂປໂຕຄອນນີ້ຖືກນໍາໃຊ້ໃນເຄື່ອງຈັກທີ່ທັນສະໄຫມຫຼາຍ. ຕົວຢ່າງ, ການບໍລິການ w32tm ໃນປ່ອງຢ້ຽມ.

ມີ 5 ລຸ້ນຂອງໂປໂຕຄອນ NTP ທັງໝົດ. ສະບັບທໍາອິດ, ຮຸ່ນ 0 (1985, RFC958)), ປະຈຸບັນຖືວ່າລ້າສະໄຫມ. ຕອນນີ້ເຄື່ອງທີ່ໃໝ່ກວ່າໄດ້ຖືກນໍາໃຊ້, ທີ 1 (1988, RFC1059), 2nd (1989, RFC1119), 3rd (1992, RFC1305) ແລະ 4th (1996, RFC2030). ຮຸ່ນ 1-4 ແມ່ນເຂົ້າກັນໄດ້ກັບກັນແລະກັນ; ພວກມັນແຕກຕ່າງກັນພຽງແຕ່ໃນຂັ້ນຕອນການດໍາເນີນການຂອງເຄື່ອງແມ່ຂ່າຍ.

ຮູບແບບຊອງ

ຕົວຊີ້ບອກການກ້າວ (ຕົວຊີ້ວັດການແກ້ໄຂ) - ຕົວເລກທີ່ຊີ້ໃຫ້ເຫັນເຖິງການເຕືອນກ່ຽວກັບການປະສານງານທີສອງ. ຄວາມໝາຍ:

• 0 - ບໍ່ມີການແກ້ໄຂ
• 1 - ນາທີສຸດທ້າຍຂອງມື້ປະກອບມີ 61 ວິນາທີ
• 2 – ນາທີສຸດທ້າຍຂອງມື້ມີ 59 ວິນາທີ
• 3 - ເຊີບເວີລົ້ມເຫລວ (ໝົດເວລາຊິ້ງ)

ຈໍານວນເວີຊັນ (ຫມາຍ​ເລກ​ສະ​ບັບ​) – NTP protocol ເລກ​ເວີ​ຊັນ (1-4​)​.

ຮູບແບບການ (mode) — ຮູບແບບການເຮັດວຽກຂອງຜູ້ສົ່ງແພັກເກັດ. ຄ່າຈາກ 0 ຫາ 7, ທົ່ວໄປທີ່ສຸດ:

• 3 - ລູກ​ຄ້າ​
• 4 - ເຊີບເວີ
• 5 - ຮູບແບບການອອກອາກາດ

ລຳ ຕົ້ນ (ລະດັບຊັ້ນ) – ຈຳນວນຊັ້ນກາງລະຫວ່າງເຊີບເວີ ແລະໂມງອ້າງອີງ (1 – ເຊີບເວີເອົາຂໍ້ມູນໂດຍກົງຈາກໂມງອ້າງອີງ, 2 – ເຊີບເວີເອົາຂໍ້ມູນຈາກເຊີບເວີທີ່ມີຊັ້ນ 1, ແລະອື່ນໆ).
ລອຍນ້ໍາ ເປັນຈຳນວນເຕັມທີ່ລົງລາຍເຊັນເປັນຕົວແທນຂອງຊ່ວງເວລາສູງສຸດລະຫວ່າງຂໍ້ຄວາມຕິດຕໍ່ກັນ. ລູກຄ້າ NTP ລະບຸຊ່ວງເວລາທີ່ມັນຄາດວ່າຈະລົງຄະແນນເຊີບເວີ, ແລະເຊີບເວີ NTP ລະບຸໄລຍະທີ່ມັນຄາດວ່າຈະຖືກສຳຫຼວດ. ຄ່າແມ່ນເທົ່າກັບສອງ logarithm ຂອງວິນາທີ.
ຄວາມແມ່ນຍໍາ (ຄວາມແມ່ນຍໍາ) ເປັນຈຳນວນເຕັມທີ່ລົງລາຍເຊັນສະແດງເຖິງຄວາມຖືກຕ້ອງຂອງໂມງລະບົບ. ຄ່າແມ່ນເທົ່າກັບສອງ logarithm ຂອງວິນາທີ.
ການຊັກຊ້າຂອງຮາກ (ຄວາມລ່າຊ້າຂອງເຊີບເວີ) – ເວລາທີ່ມັນໃຊ້ເວລາສໍາລັບການອ່ານໂມງເພື່ອເຂົ້າຫາເຊີບເວີ NTP, ເປັນຈໍານວນຈຸດຄົງທີ່ຂອງວິນາທີ.
ການກະຈາຍຂອງຮາກ (ການແຜ່ກະຈາຍຂອງເຄື່ອງແມ່ຂ່າຍ) - ການແຜ່ກະຈາຍຂອງການອ່ານໂມງເຊີຟເວີ NTP ເປັນຈໍານວນວິນາທີທີ່ມີຈຸດຄົງທີ່.
ໝາຍເລກອ້າງອີງ (ID ແຫຼ່ງ) – watch id. ຖ້າເຄື່ອງແມ່ຂ່າຍມີ stratum 1, ref id ແມ່ນຊື່ຂອງໂມງປະລໍາມະນູ (4 ຕົວອັກສອນ ASCII). ຖ້າເຄື່ອງແມ່ຂ່າຍໃຊ້ເຄື່ອງແມ່ຂ່າຍອື່ນ, id ref ປະກອບດ້ວຍທີ່ຢູ່ຂອງເຄື່ອງແມ່ຂ່າຍນີ້.
4 ຊ່ອງຂໍ້ມູນສຸດທ້າຍສະແດງເຖິງເວລາ - 32 ບິດ - ສ່ວນຈໍານວນເຕັມ, 32 ບິດ - ສ່ວນເສດສ່ວນ.
ກະສານອ້າງອີງ - ໂມງຫຼ້າສຸດໃນເຊີບເວີ.
ກຳ ເນີດ - ເວລາທີ່ແພັກເກັດຖືກສົ່ງ (ຕື່ມຂໍ້ມູນໃສ່ໂດຍເຄື່ອງແມ່ຂ່າຍ - ເພີ່ມເຕີມກ່ຽວກັບເລື່ອງນີ້ຂ້າງລຸ່ມນີ້).
ໄດ້ຮັບ – ເວລາທີ່ແພັກເກັດໄດ້ຮັບໂດຍເຊີບເວີ.
ສົ່ງ – ເວລາສົ່ງແພັກເກັດຈາກເຊີບເວີໄປໃຫ້ລູກຄ້າ (ຕື່ມຂໍ້ມູນໃສ່ໂດຍລູກຄ້າ, ເພີ່ມເຕີມຢູ່ລຸ່ມນີ້).

ພວກເຮົາຈະບໍ່ພິຈາລະນາສອງພາກສະຫນາມສຸດທ້າຍ.

ໃຫ້ຂຽນຊຸດຂອງພວກເຮົາ:

ລະຫັດແພັກເກດ

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

ເພື່ອສົ່ງ (ແລະຮັບ) packet ໄປຫາເຄື່ອງແມ່ຂ່າຍ, ພວກເຮົາຕ້ອງສາມາດເຮັດໃຫ້ມັນເຂົ້າໄປໃນ byte array.
ສໍາລັບການປະຕິບັດງານນີ້ (ແລະປີ້ນກັບກັນ), ພວກເຮົາຈະຂຽນສອງຫນ້າທີ່ - pack() ແລະ unpack():

ຟັງຊັນຊອງ

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, ຮູບແບບການ и ສົ່ງ. ການ ສົ່ງ ທ່ານຕ້ອງລະບຸເວລາປະຈຸບັນຢູ່ໃນເຄື່ອງທ້ອງຖິ່ນ (ຈໍານວນວິນາທີນັບຕັ້ງແຕ່ວັນທີ 1 ມັງກອນ 1900), ຮຸ່ນ - ໃດໆຂອງ 1-4, ໂຫມດ - 3 (ໂຫມດລູກຄ້າ).

ເຊີບເວີ, ໄດ້ຮັບການຍອມຮັບການຮ້ອງຂໍ, ຕື່ມຂໍ້ມູນໃສ່ໃນຊ່ອງຂໍ້ມູນທັງໝົດໃນແພັກເກັດ NTP, ຄັດລອກໃສ່ໃນພາກສະຫນາມ. ກຳ ເນີດ ມູນຄ່າຈາກ ສົ່ງ, ທີ່ເຂົ້າມາໃນຄໍາຮ້ອງຂໍ. ມັນເປັນຄວາມລຶກລັບສໍາລັບຂ້ອຍວ່າເປັນຫຍັງລູກຄ້າບໍ່ສາມາດຕື່ມຂໍ້ມູນໃສ່ມູນຄ່າຂອງເວລາຂອງລາວໃນພາກສະຫນາມໄດ້ທັນທີ ກຳ ເນີດ. ດັ່ງນັ້ນ, ເມື່ອແພັກເກັດກັບຄືນມາ, ລູກຄ້າມີ 4 ຄ່າເວລາ - ເວລາຄໍາຮ້ອງຂໍຖືກສົ່ງ (.ກຳ ເນີດ), ເວລາເຊີບເວີໄດ້ຮັບການຮ້ອງຂໍ (ໄດ້ຮັບ), ເວລາເຊີບເວີສົ່ງຄໍາຕອບ (ສົ່ງ) ແລະ​ເວ​ລາ​ທີ່​ໄດ້​ຮັບ​ການ​ຕອບ​ສະ​ຫນອງ​ໂດຍ​ລູກ​ຄ້າ - ມາຮອດ (ບໍ່ຢູ່ໃນຊຸດ). ການນໍາໃຊ້ຄ່າເຫຼົ່ານີ້ພວກເຮົາສາມາດກໍານົດເວລາທີ່ຖືກຕ້ອງ.

ລະຫັດການສົ່ງ ແລະຮັບຊຸດ

# 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)

ກຳລັງປະມວນຜົນຂໍ້ມູນຈາກເຊີບເວີ

ການປະມວນຜົນຂໍ້ມູນຈາກເຊີບເວີແມ່ນຄ້າຍຄືກັບການກະທໍາຂອງສຸພາບບຸລຸດອັງກິດຈາກບັນຫາເກົ່າຂອງ Raymond M. Smullyan (1978): "ຜູ້ຊາຍຄົນຫນຶ່ງບໍ່ມີໂມງໃສ່ແຂນ, ແຕ່ມີໂມງຕິດຢູ່ໃນເຮືອນທີ່ຖືກຕ້ອງ, ເຊິ່ງບາງຄັ້ງລາວລືມ. ລົມ. ມື້ຫນຶ່ງ, ລືມລົມໂມງຂອງລາວອີກເທື່ອຫນຶ່ງ, ລາວໄປຢາມຫມູ່ຂອງລາວ, ໃຊ້ເວລາຕອນແລງກັບລາວ, ແລະເມື່ອລາວກັບບ້ານ, ລາວຈັດການຕັ້ງໂມງຢ່າງຖືກຕ້ອງ. ລາວຈັດການແນວໃດຖ້າເວລາເດີນທາງບໍ່ຮູ້ຈັກລ່ວງຫນ້າ? ຄຳຕອບຄື: “ເມື່ອອອກຈາກເຮືອນ, ຄົນໜຶ່ງໄດ້ລົມໂມງຂອງຕົນ ແລະຈື່ວ່າມືຢູ່ໃນຕຳແໜ່ງໃດ. ໂດຍໄດ້ມາຫາເພື່ອນແລະອອກຈາກແຂກ, ລາວສັງເກດເຫັນເວລາມາຮອດແລະອອກເດີນທາງ. ນີ້ເຮັດໃຫ້ລາວຮູ້ວ່າລາວໄປຢ້ຽມຢາມດົນປານໃດ. ກັບຄືນບ້ານແລະເບິ່ງໂມງ, ບຸກຄົນໃດຫນຶ່ງກໍານົດໄລຍະເວລາຂອງການບໍ່ຢູ່ຂອງລາວ. ໂດຍການຫັກອອກຈາກເວລາທີ່ລາວໃຊ້ເວລາໄປຢ້ຽມຢາມ, ບຸກຄົນໃດຫນຶ່ງຊອກຫາເວລາທີ່ໃຊ້ໃນການເດີນທາງທີ່ນັ້ນແລະກັບຄືນ. ໂດຍການເພີ່ມເຄິ່ງຫນຶ່ງຂອງເວລາທີ່ໃຊ້ໃນຖະຫນົນໄປສູ່ເວລາອອກຈາກແຂກ, ລາວໄດ້ຮັບໂອກາດທີ່ຈະຊອກຫາເວລາມາຮອດເຮືອນແລະປັບມືຂອງໂມງຂອງລາວຕາມຄວາມເຫມາະສົມ.”

ຊອກຫາເວລາທີ່ເຄື່ອງແມ່ຂ່າຍເຮັດວຽກຕາມຄໍາຮ້ອງຂໍ:

1. ຊອກຫາເວລາເດີນທາງຂອງແພັກເກັດຈາກລູກຄ້າໄປຫາເຄື່ອງແມ່ຂ່າຍ: ((ມາຮອດ – ຕົ້ນ) – (ສົ່ງ – ຮັບ)) / 2
2. ຊອກຫາຄວາມແຕກຕ່າງລະຫວ່າງລູກຄ້າ ແລະເວລາເຊີບເວີ:
   ຮັບ-ກຳເນີດ-((ມາຮອດ-ຕົ້ນກຳເນີດ)-(ສົ່ງ-ຮັບ))/2 =
   2 * ຮັບ – 2 * ຕົ້ນກໍາເນີດ – ມາຮອດ + ຕົ້ນກໍາເນີດ + ສົ່ງ – ຮັບ =
   ຮັບ - ກໍາເນີດ - ມາຮອດ + ສົ່ງ

ພວກເຮົາເພີ່ມມູນຄ່າຜົນໄດ້ຮັບກັບເວລາທ້ອງຖິ່ນແລະມີຄວາມສຸກກັບຊີວິດ.

ຜົນໄດ້ຮັບຂອງຜົນໄດ້ຮັບ

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)

ເປັນປະໂຫຍດ ຫນ້າທໍາອິດ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com