🥇 एक साधारण NTP ग्राहक लेख्नुहोस्

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

त्यसोभए NTP वास्तवमा के हो? NTP सही समय सर्भरहरु संग अन्तरक्रिया को लागी एक प्रोटोकल हो। यो प्रोटोकल धेरै आधुनिक मेसिनहरूमा प्रयोग गरिन्छ। उदाहरणका लागि, विन्डोजमा w32tm सेवा।

NTP प्रोटोकलको कुल 5 संस्करणहरू छन्। पहिलो, संस्करण 0 (1985, RFC958) हाल अप्रचलित मानिन्छ। नयाँ हाल प्रयोग गरिन्छ, पहिलो (1, RFC1988), दोस्रो (1059, RFC2), तेस्रो (1989, RFC1119) र चौथो (3, RFC1992)। संस्करण 1305-4 एक अर्कासँग मिल्दो छ, तिनीहरू केवल सर्भरहरूको एल्गोरिदममा भिन्न हुन्छन्।

प्याकेज ढाँचा

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

0 - कुनै सुधार छैन
1 - दिनको अन्तिम मिनेटमा 61 सेकेन्ड हुन्छ
२ - दिनको अन्तिम मिनेटमा ५९ सेकेन्ड हुन्छ
3 - सर्भर खराबी (समय सिंक्रोनाइज गरिएको छैन)

संस्करण संख्या (संस्करण नम्बर) – NTP प्रोटोकल संस्करण नम्बर (1-4)।

मोड (मोड) - प्याकेट प्रेषकको सञ्चालन मोड। ० देखि ७ सम्मको मान, सबैभन्दा सामान्य:

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

स्ट्र्याटम (लेयरिङ स्तर) - सर्भर र सन्दर्भ घडी बीचको मध्यवर्ती तहहरूको संख्या (1 - सर्भरले सन्दर्भ घडीबाट सीधै डेटा लिन्छ, 2 - सर्भरले स्तर 1, आदिको साथ सर्भरबाट डेटा लिन्छ)।
पूल लगातार सन्देशहरू बीचको अधिकतम अन्तराल प्रतिनिधित्व गर्ने एक हस्ताक्षरित पूर्णांक हो। NTP क्लाइन्टले सर्भरमा पोल गर्ने अपेक्षा गरेको अन्तराल यहाँ निर्दिष्ट गर्दछ, र 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 =
२ * प्राप्त - २ * उत्पत्ति - आगमन + उत्पत्ति + प्रसारण - प्राप्त =
प्राप्त गर्नुहोस् - उत्पत्ति - आगमन + प्रसारण

हामी स्थानीय समयमा प्राप्त मूल्य थप्छौं र जीवनको आनन्द लिन्छौं।

नतिजाको आउटपुट

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 ग्राहक लेख्दै

प्याकेज ढाँचा

सर्भरमा प्याकेज पठाउँदै

सर्भरबाट डाटा प्रशोधन गर्दै

एक टिप्पणी थप्न Отменить ответ