მარტივი NTP კლიენტის დაწერა

გამარჯობა, ჰაბრაუზერები. დღეს მინდა ვისაუბრო იმაზე, თუ როგორ უნდა დაწეროთ თქვენი საკუთარი მარტივი NTP კლიენტი. ძირითადად, საუბარი ეხება პაკეტის სტრუქტურას და NTP სერვერის პასუხის დამუშავების მეთოდს. კოდი დაიწერება პითონში, რადგან მეჩვენება, რომ ასეთი რამეებისთვის უკეთესი ენა უბრალოდ არ არსებობს. მცოდნეები შენიშნავენ კოდის მსგავსებას ntplib კოდთან - მე "შთაგონებული" ვიყავი ამით.

რა არის ზუსტად NTP? NTP არის პროტოკოლი ზუსტი დროის სერვერებთან ურთიერთობისთვის. ეს პროტოკოლი გამოიყენება ბევრ თანამედროვე მანქანაში. მაგალითად, w32tm სერვისი Windows-ში.

სულ NTP პროტოკოლის 5 ვერსიაა. პირველი, ვერსია 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-ლი ფენის მქონე სერვერიდან და ა.შ.).
Pool არის ხელმოწერილი მთელი რიცხვი, რომელიც წარმოადგენს მაქსიმალურ ინტერვალს ზედიზედ შეტყობინებებს შორის. NTP კლიენტი აქ განსაზღვრავს ინტერვალს, რომლითაც ის ელოდება სერვერის გამოკითხვას, ხოლო NTP სერვერი განსაზღვრავს ინტერვალს, რომლის დროსაც ის ელოდება გამოკითხვას. მნიშვნელობა უდრის წამების ბინარულ ლოგარითმს.
სიზუსტე (სიზუსტე) არის ხელმოწერილი მთელი რიცხვი, რომელიც წარმოადგენს სისტემის საათის სიზუსტეს. მნიშვნელობა უდრის წამების ბინარულ ლოგარითმს.
ფესვის შეფერხება (სერვერის დაყოვნება) – დრო, რომელიც სჭირდება საათის წაკითხვებს NTP სერვერამდე მისასვლელად, წამების ფიქსირებული წერტილის სახით.
ფესვების დისპერსია (სერვერის გავრცელება) - NTP სერვერის საათის წაკითხვის გავრცელება, როგორც წამების რაოდენობა ფიქსირებული წერტილით.
Ref id (წყაროს იდენტიფიკატორი) – საათის id. თუ სერვერს აქვს ფენა 1, მაშინ ref id არის ატომური საათის სახელი (4 ASCII სიმბოლო). თუ სერვერი იყენებს სხვა სერვერს, მაშინ ref id შეიცავს ამ სერვერის მისამართს.
ბოლო 4 ველი წარმოადგენს დროს - 32 ბიტი - მთელი რიცხვი, 32 ბიტი - წილადი ნაწილი.
Reference — უახლესი საათის ჩვენებები სერვერზე.
წარმოშობა – დრო, როდესაც გაიგზავნა პაკეტი (შევსებულია სერვერის მიერ - მეტი ამის შესახებ ქვემოთ).
მიიღეთ – სერვერის მიერ პაკეტის მიღების დრო.
გადაცემა – სერვერიდან კლიენტისთვის პაკეტის გაგზავნის დრო (შევსებულია კლიენტის მიერ, ამის შესახებ ვრცლად ქვემოთ).

ჩვენ არ განვიხილავთ ბოლო ორ ველს.

მოდით დავწეროთ ჩვენი პაკეტი:

პაკეტის კოდი

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)

სერვერზე პაკეტის გაგზავნა

სერვერზე უნდა გაიგზავნოს პაკეტი შევსებული ველებით მობილური, რეჟიმი и გადაცემა. In გადაცემა თქვენ უნდა მიუთითოთ მიმდინარე დრო ლოკალურ მანქანაზე (წამების რაოდენობა 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. იპოვნეთ განსხვავება კლიენტსა და სერვერის დროს შორის:
   Receive - Originate - ((Arrive - Originate) - (Transmit - Receive)) / 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