🤙🏻 🙅🏿 💏 एक साधारण NTP क्लाइंट लिखना 🥛 🏂 ⚾️

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

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

कुल मिलाकर NTP प्रोटोकॉल के 5 संस्करण हैं। वर्तमान में पहला, 0 संस्करण (1985, RFC958) अप्रचलित माना जाता है। अब नए का उपयोग किया जाता है, 1 (1988, RFC1059), दूसरा (1989, RFC1119), तीसरा (1992, RFC1305) और 4th (1996, RFC2030)। 1-4 संस्करण एक-दूसरे के साथ संगत हैं, वे केवल सर्वर ऑपरेशन एल्गोरिदम में भिन्न हैं।

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

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

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 = "!BB bb 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))

पैकेज में लिखने के लिए संख्या के भिन्नात्मक भाग का चयन करने के लिए, हमें get_fraction () फ़ंक्शन की आवश्यकता है:

get_fraction ()

 def get_fraction(number, precision): return int((number - int(number)) * 2 ** precision)

अनपैक फंक्शन

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

हमें अनुरोध पर सर्वर का काम समय लगता है:

हमें ग्राहक से सर्वर तक पैकेट पाथ टाइम मिलता है: ((आगमन - उत्पत्ति) - (संचार - प्राप्त करें) - 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)

उपयोगी लिंक ।

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

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

सर्वर पर एक पैकेट भेजा जा रहा है

सर्वर से डेटा संसाधित करना

More articles: