एक साधारण एनटीपी क्लाइंट लिखना

हेलो हब्रूज़र्स. आज मैं इस बारे में बात करना चाहता हूं कि अपना खुद का सरल एनटीपी क्लाइंट कैसे लिखें। मूल रूप से, बातचीत पैकेट की संरचना और एनटीपी सर्वर से प्रतिक्रिया कैसे संसाधित की जाती है, इस पर केंद्रित होगी। कोड पायथन में लिखा जाएगा, क्योंकि, मेरी राय में, ऐसी चीज़ों के लिए इससे बेहतर कोई भाषा नहीं है। पारखी लोग ntplib कोड के साथ कोड की समानता पर ध्यान देंगे - मैं इससे "प्रेरित" हुआ था।

तो फिर एनटीपी क्या है? एनटीपी टाइम सर्वर के साथ संचार करने के लिए एक प्रोटोकॉल है। इस प्रोटोकॉल का उपयोग कई आधुनिक मशीनों में किया जाता है। उदाहरण के लिए, विंडोज़ पर w32tm सेवा।

NTP प्रोटोकॉल के कुल 5 संस्करण हैं। पहला, संस्करण 0 (1985, आरएफसी958) वर्तमान में अप्रचलित माना जाता है। वर्तमान में नए उपयोग किए जाते हैं, पहला (1, आरएफसी1988), दूसरा (1059, आरएफसी2), तीसरा (1989, आरएफसी1119) और चौथा (3, आरएफसी1992)। संस्करण 1305-4 एक दूसरे के साथ संगत हैं, वे केवल सर्वर के एल्गोरिदम में भिन्न हैं।

पैकेट प्रारूप

छलांग सूचक (सुधार सूचक) एक संख्या है जो लीप सेकेंड चेतावनी को इंगित करती है। अर्थ:

• 0 - कोई सुधार नहीं
• 1 - दिन के अंतिम मिनट में 61 सेकंड होते हैं
• 2 - दिन के अंतिम मिनट में 59 सेकंड होते हैं
• 3 - सर्वर विफलता (समय समन्वयन से बाहर)

संस्करण संख्या (संस्करण संख्या) - एनटीपी प्रोटोकॉल संस्करण संख्या (1-4)।

मोड (मोड) - पैकेट प्रेषक का संचालन मोड। मान 0 से 7 तक, सबसे सामान्य:

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

परत (लेयरिंग स्तर) - सर्वर और संदर्भ घड़ी के बीच मध्यवर्ती परतों की संख्या (1 - सर्वर सीधे संदर्भ घड़ी से डेटा लेता है, 2 - सर्वर स्तर 1 वाले सर्वर से डेटा लेता है, आदि)।
पूल एक हस्ताक्षरित पूर्णांक है जो लगातार संदेशों के बीच अधिकतम अंतराल का प्रतिनिधित्व करता है। एनटीपी क्लाइंट यहां उस अंतराल को निर्दिष्ट करता है जिस पर वह सर्वर से पोल होने की उम्मीद करता है, और एनटीपी सर्वर उस अंतराल को निर्दिष्ट करता है जिस पर वह पोल होने की उम्मीद करता है। मान सेकंड के बाइनरी लघुगणक के बराबर है।
शुद्धता (परिशुद्धता) सिस्टम घड़ी की सटीकता का प्रतिनिधित्व करने वाला एक हस्ताक्षरित पूर्णांक है। मान सेकंड के बाइनरी लघुगणक के बराबर है।
जड़ विलंब (सर्वर विलंबता) वह समय है जो घड़ी को एनटीपी सर्वर तक पहुंचने में सेकंड की एक निश्चित-बिंदु संख्या के रूप में लगता है।
जड़ फैलाव (सर्वर स्कैटर) - सेकंड की एक निश्चित-बिंदु संख्या के रूप में एनटीपी सर्वर घड़ी का स्कैटर।
रेफरी आईडी (स्रोत आईडी) - घड़ी आईडी। यदि सर्वर में स्ट्रेटम 1 है, तो रेफरी आईडी परमाणु घड़ी (4 एएससीआईआई वर्ण) का नाम है। यदि सर्वर किसी अन्य सर्वर का उपयोग करता है, तो रेफरी आईडी में इस सर्वर का पता होता है।
अंतिम 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

सर्वर पर एक पैकेट भेजने (और प्राप्त करने) के लिए, हमें इसे बाइट्स की एक सरणी में बदलने में सक्षम होना चाहिए।
इस (और रिवर्स) ऑपरेशन के लिए, हम दो फ़ंक्शन लिखेंगे - पैक() और अनपैक():

पैक फ़ंक्शन

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 (क्लाइंट मोड) निर्दिष्ट करना होगा।

सर्वर, अनुरोध प्राप्त करने के बाद, एनटीपी पैकेट में सभी फ़ील्ड भरता है, फ़ील्ड में कॉपी करता है उत्पन्न करना से मूल्य संचारित, जो अनुरोध में आया था। यह मेरे लिए एक रहस्य है कि ग्राहक क्षेत्र में अपने समय का मूल्य तुरंत क्यों नहीं भर सकता उत्पन्न करना. परिणामस्वरूप, जब पैकेट वापस आता है, तो क्लाइंट के पास 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) की पुरानी समस्या के अंग्रेज सज्जन के कार्यों के समान है: "एक व्यक्ति के पास कलाई घड़ी नहीं थी, लेकिन घर पर एक सटीक दीवार घड़ी थी, जिसे वह कभी-कभी हवा देना भूल जाते हैं। एक दिन, वह घड़ी को फिर से चालू करना भूल गया, वह अपने दोस्त से मिलने गया, उसके साथ शाम बिताई और जब वह घर लौटा, तो उसने घड़ी को सही ढंग से सेट किया। यदि यात्रा का समय पहले से ज्ञात नहीं था तो उसने ऐसा कैसे कर लिया? उत्तर है: “घर छोड़कर, एक व्यक्ति घड़ी को घुमाता है और हाथों की स्थिति को याद रखता है। किसी दोस्त के पास आकर मेहमानों को छोड़कर उनके आने और जाने का समय नोट कर लेता है। इससे उसे पता चल सकेगा कि वह कितनी देर दूर था। घर लौटकर घड़ी देखकर व्यक्ति अपनी अनुपस्थिति की अवधि निर्धारित करता है। इस समय में से उस समय को घटाकर, जो उसने घूमने में बिताया था, व्यक्ति को सड़क पर वहां और वापस आने में बिताया गया समय पता चलता है। सड़क पर बिताए गए समय का आधा समय मेहमानों के जाने के समय में जोड़कर, उसे घर आने का समय पता करने और अपनी घड़ी की सुइयों को तदनुसार समायोजित करने का अवसर मिलता है।

उस समय का पता लगाएं जब सर्वर अनुरोध पर काम कर रहा था:

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