🥇एक साधा NTP क्लायंट लिहा

नमस्कार, हॅब्रोझर्स. आज मला तुमचा स्वतःचा साधा NTP क्लायंट कसा लिहायचा याबद्दल बोलायचे आहे. मुळात, संभाषण पॅकेटच्या संरचनेकडे आणि NTP सर्व्हरकडून प्रतिसादावर प्रक्रिया करण्याच्या पद्धतीकडे वळेल. कोड पायथनमध्ये लिहिला जाईल, कारण मला असे वाटते की अशा गोष्टींसाठी कोणतीही चांगली भाषा नाही. पारखी ntplib कोडसह कोडची समानता लक्षात घेतील - मला त्यातून "प्रेरणा" मिळाली.

मग NTP म्हणजे नक्की काय? NTP हा अचूक वेळ सर्व्हरसह परस्परसंवादासाठी प्रोटोकॉल आहे. हा प्रोटोकॉल अनेक आधुनिक मशीनमध्ये वापरला जातो. उदाहरणार्थ, विंडोजमधील w32tm सेवा.

NTP प्रोटोकॉलच्या एकूण 5 आवृत्त्या आहेत. पहिली, आवृत्ती 0 (1985, RFC958)), सध्या अप्रचलित मानली जाते. आता नवीन वापरले जातात, 1 ला (1988, RFC1059), 2रा (1989, RFC1119), तिसरा (3, RFC1992) आणि 1305 था (4, RFC1996). आवृत्त्या 2030-1 एकमेकांशी सुसंगत आहेत; त्या फक्त सर्व्हर ऑपरेशन अल्गोरिदममध्ये भिन्न आहेत.

पॅकेजचे स्वरूप

लीप इंडिकेटर (सुधारणा सूचक) - समन्वय सेकंदाबद्दल चेतावणी दर्शवणारी संख्या. अर्थ:

0 - सुधारणा नाही
1 - दिवसाच्या शेवटच्या मिनिटात 61 सेकंद असतात
2 - दिवसाच्या शेवटच्या मिनिटात 59 सेकंद असतात
3 - सर्व्हर खराबी (वेळ समक्रमित नाही)

आवृत्ती क्रमांक (आवृत्ती क्रमांक) – NTP प्रोटोकॉल आवृत्ती क्रमांक (1-4).

मोड (मोड) - पॅकेट प्रेषकाचा ऑपरेटिंग मोड. 0 ते 7 पर्यंतचे मूल्य, सर्वात सामान्य:

3 - ग्राहक
4 - सर्व्हर
5 - प्रसारण मोड

स्ट्रॅटम (लेयरिंग लेव्हल) – सर्व्हर आणि संदर्भ घड्याळ दरम्यानच्या मध्यवर्ती स्तरांची संख्या (1 – सर्व्हर थेट संदर्भ घड्याळातून डेटा घेतो, 2 – सर्व्हर लेयर 1 इ.सह सर्व्हरवरून डेटा घेतो).
पूल सलग संदेशांमधील कमाल अंतराचे प्रतिनिधित्व करणारा एक स्वाक्षरी पूर्णांक आहे. NTP क्लायंट ज्या अंतराने सर्व्हरला मतदान करण्‍याची अपेक्षा करतो तो अंतराल येथे निर्दिष्ट करतो आणि NTP सर्व्हर ज्या अंतरावर मतदान करण्‍याची अपेक्षा करतो तो अंतराल निर्दिष्ट करतो. मूल्य सेकंदांच्या बायनरी लॉगरिथमच्या बरोबरीचे आहे.
प्रिसिजन (अचूकता) ही सिस्टीम घड्याळाची अचूकता दर्शविणारी एक स्वाक्षरी पूर्णांक आहे. मूल्य सेकंदांच्या बायनरी लॉगरिथमच्या बरोबरीचे आहे.
रूट विलंब (सर्व्हर विलंब) – घड्याळाच्या वाचनांना NTP सर्व्हरपर्यंत पोहोचण्यासाठी लागणारा वेळ, सेकंदांच्या निश्चित-बिंदू संख्येप्रमाणे.
रूट फैलाव (सर्व्हर स्प्रेड) - एनटीपी सर्व्हर क्लॉक रीडिंगचा प्रसार एका निश्चित बिंदूसह सेकंदांच्या संख्येप्रमाणे.
संदर्भ आयडी (स्रोत अभिज्ञापक) - घड्याळ आयडी. जर सर्व्हरमध्ये स्ट्रॅटम 1 असेल, तर रेफ आयडी हे अणु घड्याळाचे नाव आहे (4 ASCII वर्ण). जर सर्व्हर दुसरा सर्व्हर वापरत असेल, तर रेफ आयडीमध्ये या सर्व्हरचा पत्ता असतो.
शेवटची 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

सर्व्हरवर पॅकेट पाठवण्यासाठी (आणि प्राप्त करण्यासाठी), आम्ही ते बाइट अॅरेमध्ये बदलण्यास सक्षम असणे आवश्यक आहे.
या (आणि उलट) ऑपरेशनसाठी, आम्ही दोन फंक्शन्स लिहू - 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))

अनपॅक फंक्शन

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)

सर्व्हरवर पॅकेज पाठवत आहे

भरलेल्या फील्डसह एक पॅकेट सर्व्हरला पाठवणे आवश्यक आहे आवृत्ती, मोड и प्रक्षेपित. द प्रक्षेपित तुम्ही स्थानिक मशीनवर वर्तमान वेळ (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)

सर्व्हरवरून डेटावर प्रक्रिया करत आहे

सर्व्हरवरील डेटावर प्रक्रिया करणे हे रेमंड एम. स्मुल्यन (1978) च्या जुन्या समस्येतील इंग्रजी गृहस्थांच्या कृतींसारखेच आहे: “एका माणसाकडे मनगटाचे घड्याळ नव्हते, परंतु घरी एक अचूक भिंत घड्याळ होते, जे तो कधीकधी विसरला. वारा करण्यासाठी एके दिवशी, पुन्हा घड्याळ वळवायला विसरल्याने, तो आपल्या मित्राला भेटायला गेला, त्याच्याबरोबर संध्याकाळ घालवली आणि घरी परतल्यावर त्याने घड्याळ व्यवस्थित सेट केले. प्रवासाची वेळ अगोदरच माहीत नसेल तर त्याने हे कसे केले? उत्तर आहे: “घर सोडताना, एखादी व्यक्ती आपले घड्याळ वारा करते आणि लक्षात ठेवते की हात कोणत्या स्थितीत आहेत. मित्राकडे आल्यावर आणि पाहुण्यांना सोडल्यानंतर, तो त्याच्या येण्याची आणि जाण्याची वेळ नोंदवतो. हे त्याला किती काळ भेट देत होते हे शोधू देते. घरी परत येताना आणि घड्याळाकडे पाहताना, एखादी व्यक्ती त्याच्या अनुपस्थितीचा कालावधी ठरवते. या वेळेतून त्याने भेटीसाठी घालवलेला वेळ वजा केल्यास, एखाद्या व्यक्तीने तेथे आणि मागे प्रवास करण्यात घालवलेला वेळ शोधला जातो. पाहुण्यांना सोडण्याच्या वेळेत रस्त्यावर घालवलेला अर्धा वेळ जोडून, त्याला घरी येण्याची वेळ शोधण्याची आणि त्यानुसार घड्याळाचे हात समायोजित करण्याची संधी मिळते.”

विनंतीवर सर्व्हर किती वेळ काम करत आहे ते शोधा:

क्लायंटपासून सर्व्हरपर्यंत पॅकेटचा प्रवास वेळ शोधा: ((आगमन – उत्पत्ती) – (प्रसारण – प्राप्त)) / २
क्लायंट आणि सर्व्हरच्या वेळेतील फरक शोधा:
प्राप्त करा - मूळ - ((आगमन - उत्पत्ती) - (प्रसारण - प्राप्त करा)) / 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

एक साधा NTP क्लायंट लिहित आहे

पॅकेजचे स्वरूप

सर्व्हरवर पॅकेज पाठवत आहे

सर्व्हरवरून डेटावर प्रक्रिया करत आहे

एक टिप्पणी जोडा Отменить ответ