כתיבת לקוח NTP פשוט

שלום לפוגעים. היום אני רוצה לדבר על איך לכתוב לקוח NTP פשוט משלך. בעצם, השיחה תפנה למבנה החבילה ולאופן עיבוד התגובה משרת ה-NTP. הקוד ייכתב ב-python, כי לדעתי, פשוט אין שפה טובה יותר לדברים כאלה. אניני טעם ישימו לב לדמיון של הקוד עם קוד ntplib – "שאבתי השראה" ממנו.

אז מה זה בכלל NTP? NTP הוא פרוטוקול לתקשורת עם שרתי זמן. פרוטוקול זה משמש במכונות מודרניות רבות. לדוגמה, שירות w32tm בחלונות.

ישנן 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 מציין את המרווח שבו הוא מצפה להישאל. הערך שווה ללוגריתם הבינארי של שניות.
דיוק (דיוק) הוא מספר שלם בסימן המייצג את הדיוק של שעון המערכת. הערך שווה ללוגריתם הבינארי של שניות.
עיכוב שורש (השהיית שרת) היא הזמן שלוקח לשעון להגיע לשרת NTP, כמספר שניות קבוע.
פיזור שורשים (פיזור שרת) - הפיזור של שעון שרת NTP כמספר שניות בנקודה קבועה.
תעודת זהות (מזהה מקור) - מזהה שעון. אם לשרת יש שכבה 1, אז ref id הוא השם של השעון האטומי (4 תווי ASCII). אם השרת משתמש בשרת אחר, אזי ה-ref id מכיל את הכתובת של שרת זה.
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))

פונקציית unpack

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