એક સરળ NTP ક્લાયંટ લખવું

હેલો હેબ્રાઉઝર્સ. આજે હું તમારા પોતાના સરળ NTP ક્લાયંટને કેવી રીતે લખવું તે વિશે વાત કરવા માંગુ છું. મૂળભૂત રીતે, વાતચીત પેકેટની રચના અને NTP સર્વર તરફથી પ્રતિસાદ કેવી રીતે પ્રક્રિયા કરવામાં આવે છે તે તરફ વળશે. કોડ python માં લખવામાં આવશે, કારણ કે, મારા મતે, આવી વસ્તુઓ માટે કોઈ વધુ સારી ભાષા નથી. જાણકારો ntplib કોડ સાથે કોડની સમાનતા પર ધ્યાન આપશે - હું તેનાથી "પ્રેરિત" હતો.

તો કોઈપણ રીતે NTP શું છે? NTP એ સમય સર્વર સાથે વાતચીત કરવા માટેનો પ્રોટોકોલ છે. આ પ્રોટોકોલનો ઉપયોગ ઘણા આધુનિક મશીનોમાં થાય છે. ઉદાહરણ તરીકે, વિન્ડોઝ પર w32tm સેવા.

NTP પ્રોટોકોલના કુલ 5 વર્ઝન છે. પ્રથમ, સંસ્કરણ 0 (1985, RFC958) હાલમાં અપ્રચલિત માનવામાં આવે છે. નવાનો હાલમાં ઉપયોગ થાય છે, 1 લી (1988, RFC1059), 2જી (1989, RFC1119), ત્રીજી (3, RFC1992) અને ચોથી (1305, RFC4). આવૃત્તિઓ 1996-2030 એકબીજા સાથે સુસંગત છે, તેઓ ફક્ત સર્વરના અલ્ગોરિધમ્સમાં અલગ પડે છે.

પેકેટ ફોર્મેટ

લીપ સૂચક (સુધારણા સૂચક) એ એક સંખ્યા છે જે લીપ સેકન્ડની ચેતવણી સૂચવે છે. અર્થ:

• 0 - કોઈ સુધારો નથી
• 1 - દિવસની છેલ્લી મિનિટમાં 61 સેકન્ડનો સમાવેશ થાય છે
• 2 - દિવસની છેલ્લી મિનિટમાં 59 સેકન્ડ હોય છે
• 3 - સર્વર નિષ્ફળતા (સમન્વયનનો સમય સમાપ્ત)

સંસ્કરણ નંબર (સંસ્કરણ નંબર) – NTP પ્રોટોકોલ સંસ્કરણ નંબર (1-4).

સ્થિતિ (મોડ) - પેકેટ મોકલનારનું ઓપરેશન મોડ. 0 થી 7 મૂલ્ય, સૌથી સામાન્ય:

• 3 - ગ્રાહક
• 4 - સર્વર
• 5 - બ્રોડકાસ્ટ મોડ

સ્ટ્રેટમ (લેયરિંગ લેવલ) - સર્વર અને સંદર્ભ ઘડિયાળ વચ્ચેના મધ્યવર્તી સ્તરોની સંખ્યા (1 - સર્વર સીધા સંદર્ભ ઘડિયાળમાંથી ડેટા લે છે, 2 - સર્વર સ્તર 1 સાથે સર્વરમાંથી ડેટા લે છે, વગેરે).
સમુચ્ચય સળંગ સંદેશાઓ વચ્ચેના મહત્તમ અંતરાલનું પ્રતિનિધિત્વ કરતું સાઇન કરેલ પૂર્ણાંક છે. NTP ક્લાયંટ અહીં તે અંતરાલનો ઉલ્લેખ કરે છે કે જેના પર તે સર્વરને મતદાન કરવાની અપેક્ષા રાખે છે, અને NTP સર્વર તે અંતરાલનો ઉલ્લેખ કરે છે કે જેના પર તે મતદાન થવાની અપેક્ષા રાખે છે. મૂલ્ય સેકન્ડના દ્વિસંગી લઘુગણક જેટલું છે.
શુદ્ધતા (ચોકસાઇ) એ સિસ્ટમ ઘડિયાળની ચોકસાઈનું પ્રતિનિધિત્વ કરતી સાઇન કરેલ પૂર્ણાંક છે. મૂલ્ય સેકન્ડના દ્વિસંગી લઘુગણક જેટલું છે.
મૂળ વિલંબ (સર્વર લેટન્સી) એ ઘડિયાળને NTP સર્વર સુધી પહોંચવામાં જે સમય લાગે છે તે સેકન્ડોની નિશ્ચિત-બિંદુ સંખ્યા તરીકે છે.
રુટ વિક્ષેપ (સર્વર સ્કેટર) - સેકન્ડની નિશ્ચિત-બિંદુ સંખ્યા તરીકે NTP સર્વર ઘડિયાળનું સ્કેટર.
સંદર્ભ આઈડી (સ્ત્રોત આઈડી) – ઘડિયાળ આઈડી. જો સર્વરમાં સ્ટ્રેટમ 1 હોય, તો રેફ 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

સર્વર પર પેકેટ મોકલવા (અને પ્રાપ્ત કરવા) માટે, આપણે તેને બાઈટ્સની એરેમાં ફેરવવા માટે સક્ષમ હોવા જોઈએ.
આ (અને વિપરીત) કામગીરી માટે, અમે બે કાર્યો લખીશું - 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) ની જૂની સમસ્યામાંથી અંગ્રેજ સજ્જનની ક્રિયાઓ જેવી જ છે: “એક વ્યક્તિ પાસે કાંડા ઘડિયાળ ન હતી, પરંતુ ઘરમાં એક સચોટ દિવાલ ઘડિયાળ હતી, જે તેણે ક્યારેક પવન કરવાનું ભૂલી ગયા. એક દિવસ, ફરીથી ઘડિયાળ ચાલુ કરવાનું ભૂલી ગયો, તે તેના મિત્રને મળવા ગયો, તેની સાથે સાંજ વિતાવી, અને જ્યારે તે ઘરે પાછો આવ્યો, ત્યારે તેણે ઘડિયાળને યોગ્ય રીતે ગોઠવી. જો મુસાફરીનો સમય અગાઉથી જાણતો ન હતો તો તેણે આ કેવી રીતે કર્યું? જવાબ છે: “ઘર છોડીને, વ્યક્તિ ઘડિયાળ બંધ કરે છે અને હાથની સ્થિતિ યાદ રાખે છે. મિત્ર પાસે આવવું અને મહેમાનોને વિદાય આપવી, તે તેના આગમન અને પ્રસ્થાનનો સમય નોંધે છે. આ તેને શોધવા માટે પરવાનગી આપે છે કે તે કેટલો સમય દૂર હતો. ઘરે પાછા ફર્યા અને ઘડિયાળ જોતા, વ્યક્તિ તેની ગેરહાજરીની અવધિ નક્કી કરે છે. આ સમયમાંથી તેણે મુલાકાત લેવા માટે વિતાવેલો સમય બાદ કરીને, વ્યક્તિ ત્યાં અને પાછળના રસ્તા પર વિતાવેલો સમય શોધી કાઢે છે. રસ્તા પર વિતાવેલા સમયનો અડધો સમય મહેમાનોને છોડવાના સમય સાથે ઉમેરીને, તેને ઘરે પહોંચવાનો સમય શોધવાની અને તે મુજબ તેની ઘડિયાળના હાથ ગોઠવવાની તક મળે છે.

વિનંતી પર સર્વર કામ કરી રહ્યું હતું તે સમય શોધો:

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