ഒരു ലളിതമായ NTP ക്ലയന്റ് എഴുതുന്നു

ഹലോ, ഹബ്രൌസേഴ്സ്. നിങ്ങളുടെ സ്വന്തം NTP ക്ലയന്റ് എങ്ങനെ എഴുതാം എന്നതിനെക്കുറിച്ച് ഇന്ന് ഞാൻ സംസാരിക്കാൻ ആഗ്രഹിക്കുന്നു. അടിസ്ഥാനപരമായി, സംഭാഷണം പാക്കറ്റിന്റെ ഘടനയിലേക്കും NTP സെർവറിൽ നിന്നുള്ള പ്രതികരണം പ്രോസസ്സ് ചെയ്യുന്ന രീതിയിലേക്കും തിരിയും. കോഡ് പൈത്തണിൽ എഴുതപ്പെടും, കാരണം അത്തരം കാര്യങ്ങൾക്ക് മികച്ച ഭാഷയില്ലെന്ന് എനിക്ക് തോന്നുന്നു. ntplib കോഡുമായുള്ള കോഡിന്റെ സാമ്യം ആസ്വാദകർ ശ്രദ്ധിക്കും - ഞാൻ അതിൽ നിന്ന് “പ്രചോദിതനായി”.

അപ്പോൾ എന്താണ് യഥാർത്ഥത്തിൽ NTP? കൃത്യമായ സമയ സെർവറുകളുമായുള്ള ആശയവിനിമയത്തിനുള്ള ഒരു പ്രോട്ടോക്കോൾ ആണ് NTP. ഈ പ്രോട്ടോക്കോൾ പല ആധുനിക മെഷീനുകളിലും ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, വിൻഡോസിലെ w32tm സേവനം.

NTP പ്രോട്ടോക്കോളിന്റെ ആകെ 5 പതിപ്പുകളുണ്ട്. ആദ്യ പതിപ്പ് 0 (1985, RFC958)), നിലവിൽ കാലഹരണപ്പെട്ടതായി കണക്കാക്കപ്പെടുന്നു. ഇപ്പോൾ പുതിയവ ഉപയോഗിക്കുന്നു, 1st (1988, RFC1059), 2nd (1989, RFC1119), 3rd (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 സെർവർ ക്ലോക്ക് റീഡിംഗുകളുടെ ഒരു നിശ്ചിത പോയിന്റ് ഉപയോഗിച്ച് സെക്കൻഡുകളുടെ എണ്ണം.
റെഫ് ഐഡി (ഉറവിട ഐഡന്റിഫയർ) - ക്ലോക്ക് ഐഡി. സെർവറിന് സ്ട്രാറ്റം 1 ആണെങ്കിൽ, ref id എന്നത് ആറ്റോമിക് ക്ലോക്കിന്റെ പേരാണ് (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

സെർവറിലേക്ക് ഒരു പാക്കറ്റ് അയയ്‌ക്കാനും (സ്വീകരിക്കാനും) ഞങ്ങൾക്ക് അത് ഒരു ബൈറ്റ് അറേ ആക്കി മാറ്റാൻ കഴിയണം.
ഈ (ഒപ്പം റിവേഴ്സ്) പ്രവർത്തനത്തിനായി, ഞങ്ങൾ രണ്ട് ഫംഗ്ഷനുകൾ എഴുതും - പാക്ക് () ഉം അൺപാക്ക് ():

പാക്ക് ഫംഗ്ഷൻ

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) പഴയ പ്രശ്നത്തിൽ നിന്നുള്ള ഇംഗ്ലീഷ് മാന്യന്റെ പ്രവർത്തനങ്ങൾക്ക് സമാനമാണ്: “ഒരാൾക്ക് റിസ്റ്റ് വാച്ച് ഇല്ലായിരുന്നു, പക്ഷേ വീട്ടിൽ കൃത്യമായ ഒരു മതിൽ ക്ലോക്ക് ഉണ്ടായിരുന്നു, അത് അവൻ ചിലപ്പോൾ മറന്നു. കാറ്റിലേക്ക്. ഒരു ദിവസം, വാച്ച് വീണ്ടും വിൻഡ് ചെയ്യാൻ മറന്നതിനാൽ, അവൻ തന്റെ സുഹൃത്തിനെ കാണാൻ പോയി, വൈകുന്നേരം അവനോടൊപ്പം ചെലവഴിച്ചു, വീട്ടിൽ തിരിച്ചെത്തിയപ്പോൾ, വാച്ച് ശരിയായി സജ്ജമാക്കാൻ അയാൾക്ക് കഴിഞ്ഞു. യാത്രാ സമയം മുൻകൂട്ടി അറിഞ്ഞില്ലെങ്കിൽ അയാൾക്ക് എങ്ങനെ ഇത് ചെയ്യാൻ കഴിഞ്ഞു? ഉത്തരം ഇതാണ്: “വീട്ടിൽ നിന്ന് പുറത്തുപോകുമ്പോൾ, ഒരു വ്യക്തി തന്റെ വാച്ചിൽ വീശുകയും കൈകൾ ഏത് സ്ഥാനത്താണ് എന്ന് ഓർക്കുകയും ചെയ്യുന്നു. ഒരു സുഹൃത്തിന്റെ അടുത്ത് വന്ന് അതിഥികളെ ഉപേക്ഷിച്ച്, അവൻ വരുന്നതിന്റെയും പുറപ്പെടലിന്റെയും സമയം രേഖപ്പെടുത്തുന്നു. അവൻ എത്ര സമയം സന്ദർശിച്ചുവെന്ന് കണ്ടെത്താൻ ഇത് അവനെ അനുവദിക്കുന്നു. വീട്ടിലേക്ക് മടങ്ങുകയും ക്ലോക്കിലേക്ക് നോക്കുകയും ചെയ്യുമ്പോൾ, ഒരു വ്യക്തി തന്റെ അഭാവത്തിന്റെ ദൈർഘ്യം നിർണ്ണയിക്കുന്നു. ഈ സമയത്തിൽ നിന്ന് താൻ സന്ദർശിച്ച സമയം കുറയ്ക്കുന്നതിലൂടെ, ഒരു വ്യക്തി അവിടെയും തിരിച്ചും യാത്ര ചെയ്ത സമയം കണ്ടെത്തുന്നു. വഴിയിൽ ചെലവഴിക്കുന്ന സമയത്തിന്റെ പകുതി സമയവും അതിഥികൾ പുറത്തിറങ്ങുന്ന സമയവും കൂട്ടിച്ചേർത്താൽ, വീട്ടിലെത്താനുള്ള സമയം കണ്ടെത്താനും അതിനനുസരിച്ച് വാച്ചിന്റെ കൈകൾ ക്രമീകരിക്കാനും അയാൾക്ക് അവസരം ലഭിക്കുന്നു.

ഒരു അഭ്യർത്ഥനയിൽ സെർവർ പ്രവർത്തിക്കുന്ന സമയം കണ്ടെത്തുക:

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