សរសេរម៉ាស៊ីនភ្ញៀវ NTP សាមញ្ញ

សួស្ដី​អ្នក​ប្រើ​ប្រាស់។ ថ្ងៃនេះខ្ញុំចង់និយាយអំពីរបៀបសរសេរម៉ាស៊ីនភ្ញៀវ NTP សាមញ្ញផ្ទាល់ខ្លួនរបស់អ្នក។ ជាទូទៅ ការសន្ទនានឹងប្រែទៅជារចនាសម្ព័ន្ធនៃកញ្ចប់ព័ត៌មាន និងរបៀបដែលការឆ្លើយតបពីម៉ាស៊ីនមេ NTP ត្រូវបានដំណើរការ។ កូដនឹងត្រូវបានសរសេរជា python ព្រោះតាមគំនិតរបស់ខ្ញុំ វាមិនមានភាសាល្អជាងសម្រាប់រឿងបែបនេះទេ។ Connoisseurs នឹងយកចិត្តទុកដាក់ចំពោះភាពស្រដៀងគ្នានៃកូដជាមួយលេខកូដ ntplib - ខ្ញុំត្រូវបាន "បំផុសគំនិត" ដោយវា។

ដូច្នេះ NTP ជាអ្វី? NTP គឺជាពិធីការសម្រាប់ទំនាក់ទំនងជាមួយម៉ាស៊ីនមេពេលវេលា។ ពិធីការនេះត្រូវបានប្រើនៅក្នុងម៉ាស៊ីនទំនើបជាច្រើន។ ឧទាហរណ៍ សេវា w32tm នៅលើ windows ។

មាន 5 កំណែនៃពិធីការ NTP សរុប។ ទីមួយ កំណែ 0 (1985, RFC958) បច្ចុប្បន្នត្រូវបានចាត់ទុកថាលែងប្រើហើយ។ ថ្មី​ជាង​នេះ​ត្រូវ​បាន​ប្រើ​នា​ពេល​បច្ចុប្បន្ន ទី 1 (1988, RFC1059), ទី 2 (1989, RFC1119), ទី 3 (1992, RFC1305) និង​ទី 4 (1996, RFC2030) ។ កំណែ 1-4 គឺត្រូវគ្នាជាមួយគ្នាទៅវិញទៅមក ពួកវាខុសគ្នាតែនៅក្នុងក្បួនដោះស្រាយរបស់ម៉ាស៊ីនមេប៉ុណ្ណោះ។

ទម្រង់កញ្ចប់

សូចនាករលោត (សូចនាករកែតម្រូវ) គឺជាលេខដែលបង្ហាញពីការព្រមានទីពីរលោត។ អត្ថន័យ៖

• 0 - គ្មានការកែតម្រូវ
• 1 - នាទីចុងក្រោយនៃថ្ងៃមាន 61 វិនាទី
• 2 - នាទីចុងក្រោយនៃថ្ងៃមាន 59 វិនាទី
• 3 - ម៉ាស៊ីនមេបរាជ័យ (អស់ពេលធ្វើសមកាលកម្ម)

លេខកំណែ (លេខកំណែ) - លេខកំណែពិធីការ NTP (1-4) ។

របៀប (របៀប) — របៀបប្រតិបត្តិការរបស់អ្នកផ្ញើកញ្ចប់ព័ត៌មាន។ តម្លៃពី 0 ដល់ 7 ដែលជារឿងធម្មតាបំផុត៖

• 3 - អតិថិជន
• 4 - ម៉ាស៊ីនមេ
• 5 - របៀបផ្សាយ

ស្រទាប់ (កម្រិតស្រទាប់) - ចំនួននៃស្រទាប់មធ្យមរវាងម៉ាស៊ីនមេ និងនាឡិកាយោង (1 - ម៉ាស៊ីនមេយកទិន្នន័យដោយផ្ទាល់ពីនាឡិកាយោង, 2 - ម៉ាស៊ីនមេយកទិន្នន័យពីម៉ាស៊ីនមេដែលមានកម្រិត 1 ។ល។)
អាងហែលទឹក គឺជាចំនួនគត់ដែលបានចុះហត្ថលេខាតំណាងឱ្យចន្លោះពេលអតិបរមារវាងសារជាប់គ្នា។ ម៉ាស៊ីនភ្ញៀវ NTP បញ្ជាក់នៅទីនេះចន្លោះពេលដែលវារំពឹងថានឹងធ្វើការស្ទង់មតិលើម៉ាស៊ីនមេ ហើយម៉ាស៊ីនមេ NTP បញ្ជាក់ចន្លោះពេលដែលវារំពឹងថានឹងត្រូវបានបោះឆ្នោត។ តម្លៃគឺស្មើនឹងលោការីតគោលពីរនៃវិនាទី។
ភាពជាក់លាក់ (ភាពជាក់លាក់) គឺជាចំនួនគត់ដែលបានចុះហត្ថលេខាតំណាងឱ្យភាពត្រឹមត្រូវនៃនាឡិកាប្រព័ន្ធ។ តម្លៃគឺស្មើនឹងលោការីតគោលពីរនៃវិនាទី។
ការពន្យាពេលជា root (ភាពយឺតរបស់ម៉ាស៊ីនមេ) គឺជាពេលវេលាដែលវាត្រូវការសម្រាប់នាឡិកាដើម្បីទៅដល់ម៉ាស៊ីនមេ NTP ដែលជាចំនួនថេរនៃវិនាទី។
ការបែកខ្ញែកជា root (ខ្ចាត់ខ្ចាយម៉ាស៊ីនមេ) - ការខ្ចាត់ខ្ចាយនៃនាឡិកាម៉ាស៊ីនមេ NTP ជាចំនួនចំណុចថេរនៃវិនាទី។
លេខសម្គាល់ឯកសារយោង (លេខសម្គាល់ប្រភព) - មើលលេខសម្គាល់។ ប្រសិនបើម៉ាស៊ីនមេមាន stratum 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

ដើម្បីផ្ញើ (និងទទួល) កញ្ចប់ព័ត៌មានទៅម៉ាស៊ីនមេ យើងត្រូវតែអាចប្រែក្លាយវាទៅជាអារេនៃបៃ។
សម្រាប់ប្រតិបត្តិការនេះ (និងបញ្ច្រាស) យើងនឹងសរសេរមុខងារពីរគឺ 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)

ដំណើរការទិន្នន័យពីម៉ាស៊ីនមេ

ដំណើរការទិន្នន័យពីម៉ាស៊ីនមេគឺស្រដៀងគ្នាទៅនឹងសកម្មភាពរបស់សុភាពបុរសជនជាតិអង់គ្លេសពីបញ្ហាចាស់របស់ Raymond M. Smallian (1978): "មនុស្សម្នាក់មិនមាននាឡិកាដៃទេ ប៉ុន្តែមាននាឡិកាជញ្ជាំងត្រឹមត្រូវនៅផ្ទះដែលគាត់ ពេលខ្លះភ្លេចខ្យល់។ ថ្ងៃមួយដោយភ្លេចចាប់ផ្តើមនាឡិកាម្តងទៀត គាត់បានទៅលេងមិត្តរបស់គាត់ ចំណាយពេលល្ងាចជាមួយគាត់ ហើយពេលគាត់ត្រលប់មកផ្ទះវិញ គាត់រៀបចំនាឡិកាបានត្រឹមត្រូវ។ តើ​គាត់​ចាត់ចែង​ធ្វើ​បែប​នេះ​ដោយ​របៀប​ណា បើ​មិន​ដឹង​ពេល​ធ្វើ​ដំណើរ​មុន? ចំលើយគឺ៖ “ចេញពីផ្ទះ មនុស្សម្នាក់បក់នាឡិកា ហើយចងចាំទីតាំងដៃ។ មករកមិត្តភ័ក្តិ ហើយចាកចេញពីភ្ញៀវ គាត់កត់សម្គាល់ពេលវេលានៃការមកដល់ និងការចាកចេញរបស់គាត់។ នេះអនុញ្ញាតឱ្យគាត់ដឹងថាគាត់នៅឆ្ងាយប៉ុន្មាន។ ត្រលប់មកផ្ទះវិញហើយមើលនាឡិកាមនុស្សម្នាក់កំណត់រយៈពេលនៃការអវត្តមានរបស់គាត់។ ដក​ចេញ​ពី​វេលា​ដែល​ខ្លួន​បាន​ទៅ​សួរ​សុខ​ទុក្ខ បុគ្គល​នោះ​រក​ឃើញ​វេលា​ដែល​ចំណាយ​លើ​ផ្លូវ​ទី​នោះ និង​ត្រឡប់​មក​វិញ។ ដោយបន្ថែមពាក់កណ្តាលពេលវេលាដែលចំណាយលើផ្លូវទៅកាន់ពេលវេលាចាកចេញពីភ្ញៀវ គាត់ទទួលបានឱកាសដើម្បីស្វែងរកម៉ោងមកដល់ផ្ទះ និងកែតម្រូវដៃនាឡិការបស់គាត់ឱ្យសមស្រប។

ស្វែងរកពេលវេលាដែលម៉ាស៊ីនមេកំពុងដំណើរការលើសំណើ៖

1. ស្វែងរកពេលវេលាធ្វើដំណើរនៃកញ្ចប់ព័ត៌មានពីអតិថិជនទៅម៉ាស៊ីនមេ៖ ((មកដល់-ដើម)-(បញ្ជូន-ទទួល))/២
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