Rust實作DNS查詢與時間同步

– 16 分鐘閱讀

本文將逐步講解使用 Rust 語言實作 DNS 查詢的過程，涵蓋建立 UDP Socket、傳送 DNS 請求、解析 DNS 回應等關鍵步驟。同時，我們也會探討如何建立 NTP 客戶端以實作時間同步，並深入研究時間處理的複雜性，例如時區、時差和閏秒等問題。這些技術對於構建穩健的網路應用至關重要，特別是在需要精確時間同步和可靠 DNS 解析的場景下。透過 Rust 語言的系統級程式設計能力，我們可以更有效地控制網路操作和時間管理，從而提升應用程式的效能和可靠性。

使用Rust語言實作DNS查詢

在實作DNS查詢的過程中，我們需要建立一個DNS請求，並將其傳送到DNS伺服器。以下是使用Rust語言實作DNS查詢的步驟：

步驟1：定義DNS伺服器地址

首先，我們需要定義DNS伺服器的地址。這可以透過以下程式碼實作：

let dns_server_address = format!("{}:53", "8.8.8.8");

這裡，我們使用format!宏定義了一個字串，該字串包含DNS伺服器的地址和埠號。

步驟2：解析DNS伺服器地址

接下來，我們需要解析DNS伺服器的地址。這可以透過以下程式碼實作：

let dns_server: SocketAddr = dns_server_address.parse().map_err(DnsError::ParseDnsServerAddress)?;

這裡，我們使用parse方法解析DNS伺服器的地址，並將其轉換為SocketAddr型別。如果解析失敗，我們會傳回一個錯誤。

步驟3：建立請求緩衝區

然後，我們需要建立一個請求緩衝區。這可以透過以下程式碼實作：

let mut request_buffer: Vec<u8> = Vec::with_capacity(64);

這裡，我們建立了一個容量為64的向量，該向量將用於儲存DNS請求。

步驟4：建立回應緩衝區

接下來，我們需要建立一個回應緩衝區。這可以透過以下程式碼實作：

let mut response_buffer: Vec<u8> = vec![0; 512];

這裡，我們建立了一個容量為512的向量，該向量將用於儲存DNS回應。

步驟5：建立DNS請求

然後，我們需要建立一個DNS請求。這可以透過以下程式碼實作：

let mut request = Message::new();
request.add_query(Query::query("example.com", RecordType::A));

這裡，我們建立了一個新的DNS請求，並增加了一個查詢項。查詢項包含了網域名稱和記錄型別。

內容解密：

在上面的程式碼中，我們使用了Message和Query型別來建立DNS請求。Message型別代表了一個DNS訊息，而Query型別代表了一個DNS查詢項。查詢項包含了網域名稱和記錄型別。在這個例子中，我們查詢的是example.com的A記錄。

圖表翻譯：

以下是DNS請求的Mermaid圖表：

  sequenceDiagram
    participant DNS Client
    participant DNS Server
    DNS Client->>DNS Server: DNS Request
    DNS Server->>DNS Client: DNS Response

這個圖表展示了DNS客戶端和DNS伺服器之間的互動過程。DNS客戶端傳送一個DNS請求到DNS伺服器，然後DNS伺服器傳回一個DNS回應。

圖表解釋：

在這個圖表中，DNS客戶端代表了傳送DNS請求的客戶端，而DNS伺服器代表了接收和處理DNS請求的伺服器。DNS請求包含了查詢項，而DNS回應包含了查詢結果。在這個例子中，DNS客戶端查詢的是example.com的A記錄，然後DNS伺服器傳回了查詢結果。

建立 DNS 查詢請求

首先，我們需要建立一個 DNS 查詢請求。這涉及到設定查詢的 ID、訊息型別、操作碼以及是否需要遞迴查詢。

// 設定查詢 ID
request.set_id(message_id());

// 設定訊息型別為查詢
request.set_message_type(MessageType::Query);

// 設定操作碼為查詢
request.set_op_code(OpCode::Query);

// 啟用遞迴查詢
request.set_recursion_desired(true);

建立 UDP Socket 並繫結本地埠

接下來，我們需要建立一個 UDP Socket 並將其繫結到本地的一個可用埠。這是因為 DNS 查詢通常使用 UDP 協定進行。

// 繫結 UDP Socket 到本地任意可用埠
let localhost = UdpSocket::bind("0.0.0.0:0").map_err(DnsError::Network)?;

設定 Socket 超時時間

為了避免無限等待， мы 需要設定 Socket 的超時時間。

// 設定超時時間為 5 秒
let timeout = Duration::from_secs(5);

// 對 Socket 設定讀取超時
localhost.set_read_timeout(Some(timeout)).map_err(DnsError::Network)?;

內容解密：

上述程式碼片段展示瞭如何建立一個 DNS 查詢請求以及設定相關的引數。首先，request 物件被設定了查詢 ID、訊息型別、操作碼和遞迴查詢標誌。接著，建立了一個 UDP Socket 並繫結到本地任意可用埠，這是 DNS 查詢的必要步驟。最後，設定了 Socket 的超時時間，以避免因等待 DNS 回應而導致的無限等待。

圖表翻譯：

  flowchart TD
    A[建立查詢請求] --> B[設定查詢 ID]
    B --> C[設定訊息型別和操作碼]
    C --> D[啟用遞迴查詢]
    D --> E[建立 UDP Socket]
    E --> F[繫結本地埠]
    F --> G[設定 Socket 超時]
    G --> H[傳送查詢請求]

此流程圖描述了建立 DNS 查詢請求的步驟，從設定查詢引數到建立和設定 UDP Socket，最後是傳送查詢請求。

DNS 查詢過程實作

在實作 DNS 查詢過程中，我們需要建立一個非阻塞的網路連線，以便能夠同時傳送和接收資料。以下是實作 DNS 查詢過程的步驟：

步驟 1：建立非阻塞網路連線

首先，我們需要建立一個非阻塞的網路連線，以便能夠同時傳送和接收資料。這可以透過 set_nonblocking 方法實作：

localhost.set_nonblocking(false)?;

這行程式碼設定了 localhost 的非阻塞模式為 false，表示我們想要建立一個阻塞的網路連線。

步驟 2：編碼 DNS 請求

接下來，我們需要編碼 DNS 請求，以便能夠透過網路傳輸。這可以透過 BinEncoder 類別實作：

let mut encoder = BinEncoder::new(&mut request_buffer);
request.emit(&mut encoder).map_err(DnsError::Encoding)?;

這行程式碼建立了一個 BinEncoder 例項，並使用 emit 方法將 DNS 請求編碼到 request_buffer 中。

步驟 3：傳送 DNS 請求

然後，我們需要傳送 DNS 請求到 DNS 伺服器。這可以透過 send_to 方法實作：

let _n_bytes_sent = localhost.send_to(&request_buffer, dns_server).map_err(DnsError::Sending)?;

這行程式碼發送了 DNS 請求到 dns_server，並傳回了傳送的 byte 數量。

步驟 4：接收 DNS 回應

最後，我們需要接收 DNS 回應。這可以透過 recv_from 方法實作：

loop {
    let (_b_bytes_recv, remote_port) = localhost.recv_from(&mut response_buffer).map_err(DnsError::Receving)?;
    if remote_port == dns_server {
        break;
    }
}

這行程式碼建立了一個迴圈，持續接收 DNS 回應，直到收到來自 dns_server 的回應為止。

內容解密：

在上述程式碼中，我們使用了 BinEncoder 類別來編碼 DNS 請求，並使用 send_to 方法來傳送 DNS 請求。然後，我們使用 recv_from 方法來接收 DNS 回應，並使用迴圈來持續接收回應，直到收到來自 dns_server 的回應為止。

圖表翻譯：

以下是 DNS 查詢過程的 Mermaid 圖表：

  sequenceDiagram
    participant Localhost as "localhost"
    participant DnsServer as "dns_server"
    Localhost->>DnsServer: send dns request
    DnsServer->>Localhost: send dns response
    Localhost->>Localhost: receive dns response

這個圖表描述了 DNS 查詢過程中，localhost 如何傳送 DNS 請求到 DNS 伺服器，並接收 DNS 回應。

DNS 訊息構建與查詢處理

在 DNS 協定中，訊息的構建和查詢的處理是非常重要的步驟。讓我們深入瞭解如何構建 DNS 訊息以及如何處理查詢。

構建 DNS 訊息

當我們想要傳送一個 DNS 查詢時，我們需要構建一個 DNS 訊息。這個訊息包含了查詢的相關資訊，例如網域名稱、查詢型別等。以下是構建 DNS 訊息的基本步驟：

  1. 定義查詢型別：首先，我們需要定義查詢型別，例如 A 錄、MX 錄等。
  2. 設定網域名稱：然後，我們需要設定要查詢的網域名稱。
  3. 設定查詢旗標：我們需要設定查詢旗標，例如是否要求遞迴查詢等。

處理查詢

當 DNS 伺服器收到一個查詢時，它會進行以下步驟：

  1. 解析查詢：DNS 伺服器會解析查詢，提取出查詢型別、網域名稱等資訊。
  2. 查詢快取：DNS 伺服器會先查詢自己的快取，如果快取中有相關的記錄，則直接傳回結果。
  3. 遞迴查詢：如果快取中沒有相關的記錄，DNS 伺服器會進行遞迴查詢，向長官 DNS 伺服器傳送查詢。
  4. 傳回結果：最終，DNS 伺服器會傳回查詢結果給客戶端。

實作 DNS 訊息構建

以下是使用 Rust 語言實作 DNS 訊息構建的範例：

let mut response_buffer = Vec::new();
//...
let response = Message::from_vec(&response_buffer)
   .map_err(DnsError::Decoding)?;

在這個範例中，我們使用 Message::from_vec 函式從原始位元組串構建 DNS 訊息。

圖表翻譯：

下面是 DNS 查詢過程的流程圖：

  flowchart TD
    A[客戶端] -->|傳送查詢|> B[DNS 伺服器]
    B -->|解析查詢|> C[查詢快取]
    C -->|快取命中|> D[傳回結果]
    C -->|快取未命中|> E[遞迴查詢]
    E -->|傳送查詢|> F[長官 DNS 伺服器]
    F -->|傳回結果|> B
    B -->|傳回結果|> A

這個流程圖展示了 DNS 查詢過程中的各個步驟，包括客戶端傳送查詢、DNS 伺服器解析查詢、查詢快取、遞迴查詢和傳回結果等。

網路基礎：UDP 通訊與 DNS 解析

在網路通訊中，UDP（User Datagram Protocol）是一種無連線的傳輸協定，允許應用程式之間交換資料包。當我們使用UDP進行通訊時，需要指定一個埠號來接收資料包。然而，如果我們將埠號設為0，則作業系統會自動分配一個可用的埠號。

自動分配埠號

當我們將UDP socket繫結到埠號0時，作業系統會自動分配一個可用的埠號。這個過程稱為「動態埠組態」。這樣做的好處是，可以讓作業系統自動管理埠號的分配，避免手動組態埠號的麻煩。

然而，當我們使用自動分配的埠號時，也有一個小小的風險。因為作業系統分配的埠號可能已經被其他應用程式使用過，所以有可能會收到來自未知傳送者的UDP資料包。為了避免這種情況，我們可以忽略來自未知IP地址的資料包。

忽略未知IP地址的資料包

為了避免收到來自未知傳送者的UDP資料包，我們可以設定一個白名單，只接收來自預期IP地址的資料包。這樣做可以有效地防止未知傳送者送來的資料包乾擾我們的通訊。

DNS 解析

在網路通訊中，DNS（Domain Name System）是一個重要的組成部分。DNS負責將網域名稱解析成IP地址。當我們需要連線到一個遠端伺服器時，首先需要將網域名稱解析成IP地址。

下面是一個簡單的DNS解析範例：

for answer in response.answers() {
    if answer.record_type() == RecordType::A {
        let resource = answer.rdata();
        let server_ip = resource.to_ip_addr().expect("invalid IP address received");
        return Ok(Some(server_ip));
    }
}

在這個範例中，我們使用了一個迴圈來遍歷DNS回應中的答案。如果答案的型別是A（IPv4地址），則我們可以提取出IP地址並傳回。

內容解密：

  • response.answers()：這個方法傳回一個迴圈，用於遍歷DNS回應中的答案。
  • answer.record_type() == RecordType::A：這個條件判斷答案的型別是否是A（IPv4地址）。
  • let resource = answer.rdata()：這個陳述式提取出答案中的資源記錄。
  • let server_ip = resource.to_ip_addr().expect("invalid IP address received")：這個陳述式將資源記錄轉換成IP地址，如果失敗則傳回錯誤訊息。
  • return Ok(Some(server_ip))：如果成功提取出IP地址，則傳回一個Ok值，包含IP地址。

圖表翻譯：

  flowchart TD
    A[開始] --> B[取得DNS回應]
    B --> C[遍歷答案]
    C --> D[判斷答案型別]
    D --> E[提取IP地址]
    E --> F[傳回IP地址]

在這個圖表中，我們展示了DNS解析的過程。首先，我們取得DNS回應，然後遍歷答案，判斷答案型別，如果是A型別，則提取出IP地址並傳回。

時間與時序維護

在這個章節中，您將會建立一個NTP（Network Time Protocol）客戶端，該客戶端可以從全球公共時間伺服器請求當前的時間。這是一個完全功能性的客戶端，可以在您的電腦啟動過程中使用，以保持電腦與世界時間的同步。

瞭解電腦內部的時間運作機制，有助於您建立更強健的應用程式。系統時鐘可能會向前或向後跳躍，瞭解這種情況發生的原因，可以讓您預料和準備好應對。您的電腦還包含多個實體和虛擬時鐘，瞭解每個時鐘的限制和何時使用它們是適合的，需要一些知識。

瞭解每個時鐘的限制，應該會培養您對微型 benchmark 和其他時間敏感程式碼的健康懷疑態度。

一些最困難的軟體工程涉及分散式系統，它們需要就時間達成一致。如果您有 Google 的資源，您可以維護一個提供全球時間同步的原子鐘網路，精確度可達 7 毫秒。最接近的開源替代方案是 CockroachDB（https://cockroachdb.org/），其精確度約為幾十毫秒。但是，這並不意味著它是無用的。在本地網路中佈署時，NTP 可以讓電腦在幾毫秒或更短的時間內就時間達成一致。

在 Rust 方面，這個章節將花費大量時間與作業系統內部進行互動。您將會更加熟悉作業系統的內部工作原理，並學習如何使用 Rust 來與作業系統進行互動。

時間同步的重要性

時間同步對於分散式系統至關重要，因為它可以確保所有系統之間的時間一致性。這對於需要協調多個系統的應用程式，例如金融交易、物流管理等，是非常重要的。

NTP 客戶端的實作

要實作一個 NTP 客戶端，需要了解 NTP 的工作原理和協定細節。NTP 使用 UDP 協定，客戶端傳送請求給伺服器，伺服器回應當前的時間。客戶端可以根據伺服器的回應來調整自己的時間。

以下是使用 Rust 實作一個簡單的 NTP 客戶端的例子：

use std::net::UdpSocket;
use std::time::SystemTime;

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:123").expect("Failed to bind socket");
    let server_addr = "time.nist.gov:123";
    let request = [0x23, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
    socket.send_to(&request, server_addr).expect("Failed to send request");
    let mut response = [0; 48];
    socket.recv_from(&mut response).expect("Failed to receive response");
    let timestamp = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
    println!("Current time: {:?}", timestamp);
}

這個例子中，我們使用 UdpSocket 來建立一個 UDP 連線，然後傳送一個 NTP 請求給伺服器。伺服器回應後，我們可以根據回應來調整自己的時間。

時間與時序

時間是電腦系統中一個非常重要的概念，因為它直接影響著系統的運作和效率。然而，時間的處理並不像我們想象中那樣簡單。地球的自轉不是完全均勻的，會受到潮汐摩擦和其他因素的影響，導致每天的長度會有所不同。

背景

電腦系統通常假設每秒的長度是相同的，但實際上，地球的自轉並不完美。這種不完美會導致問題，例如在2012年，許多服務（包括Reddit和Mozilla的Hadoop基礎設施）在新增閏秒後停止運作。此外，時鐘可能會倒退（雖然本章不涉及時間旅行），而軟體系統通常不準備好處理同一時間戳出現兩次的情況。

時間的選擇

有兩種方法可以解決這個問題：

  1. 保持每秒的長度固定：這對於電腦來說是好的，但對於人類來說可能會令人沮喪。隨著時間的推移，「中午」會逐漸偏離太陽的位置。
  2. 調整每年的長度以保持太陽相對於中午的位置不變：這對於人類來說是好的，但對於電腦來說可能會令人沮喪。

在實踐中，我們可以選擇兩種方法。世界上的原子時鐘使用自己的時區，具有固定長度的秒，稱為TAI（國際原子時間）。其他所有時區都會定期調整，以保持與TAI的同步。TAI使用固定長度的年，而UTC（協調世界時）則在TAI的基礎上新增閏秒，大約每18個月一次。

時間來源

電腦不能直接觀察牆上的時鐘來確定現在的時間。它們需要透過其他方式來確定時間。數字時鐘由兩部分組成：一部分是以規律間隔發出滴答聲的元件，另一部分是計數器。計數器的一部分隨著滴答聲的發生而遞增，另一部分則隨著秒鐘的流逝而遞增。

電腦系統中有兩種時鐘：一種是電池供電的實時時鐘（RTC），另一種是系統時鐘。系統時鐘在電腦啟動後接管時間keeping任務，並根據硬體中斷來遞增時間。

時間編碼

時間可以在電腦中以多種方式表示。典型的方法是使用一對32位整數：一部分計數從某個起始點（epoch）以來的秒數，另一部分代表秒的小數部分。起始點是任意的，最常見的epoch是在UNIX基礎系統中使用的1970年1月1日UTC時間。

使用固定寬度整數表示時間有兩個主要優點和兩個主要挑戰：

  • 優點：
    • 簡單：格式易於理解。
    • 效率：整數運算是CPU最喜歡的活動。
  • 挑戰：
    • 固定範圍：所有固定整數型別都是有限的，這意味著時間最終會環繞回0。
    • 不準確：整數是離散的，而時間是連續的。不同的系統對於次秒精確度做出不同的權衡，從而導致四捨五入錯誤。

時間術語

本章需要介紹一些術語：

  • 絕對時間：描述你會告訴別人現在時間的時間，也被稱為牆上時鐘時間或曆法時間。
  • 實時時鐘：一種物理時鐘嵌入在電腦主機板中，即使在斷電的情況下也能保持時間。
  • 系統時鐘：作業系統對時間的看法。在啟動後，作業系統接管了時間keeping任務。
  • 單調遞增：一種永遠不會提供相同時間兩次的時鐘。這對於電腦應用程式是一個有用的屬性，因為它可以確保日誌訊息永遠不會有重複的時間戳。
  • 穩定時鐘：提供兩個保證：其秒都是等長的，並且是單調遞增的。穩定時鐘的值不太可能與系統時鐘或絕對時間對齊。
  • 高精確度：一種秒長度規律的時鐘。兩個時鐘之間的差異被稱為偏差。高精確度時鐘具有很小的偏差，相比於人類最佳工程努力保持準確時間的原子時鐘。
  • 高解析度：提供10納秒或更低的精確度。高解析度時鐘通常在CPU晶片中實作，因為很少有裝置能夠在如此高頻率下維持時間。
  • 快速時鐘：一種讀取時間需要很少時間的時鐘。快速時鐘犧牲準確性和精確度以換取速度。

時間與時區的基礎

時間和時區是電腦科學中非常重要的概念，尤其是在網路應用和全球化的背景下。不同的系統和語言對時間和時區有不同的表示方法。

時間表示

時間可以用多種方式表示，包括：

  • Unix時間（Unix time）：自1970年1月1日00:00:00 UTC以來的秒數。
  • Windows FILETIME：自1601年1月1日00:00:00 UTC以來的100納秒增量。
  • Rust的chronos crate：使用32位整數表示時間，並使用列舉表示時區。

時區表示

時區是政治分割槽，而不是技術分割槽。一個常見的做法是儲存另一個整數，表示與UTC的秒數偏移量。

時間和時區在程式設計中的應用

在程式設計中，時間和時區的表示和處理非常重要。以下是一個簡單的例子，展示如何使用Rust語言讀取系統時間並格式化為ISO 8601標準。

時間格式化

ISO 8601是一個國際標準，定義了日期和時間的格式。以下是如何使用Rust的chrono crate讀取系統時間並格式化為ISO 8601標準的例子：

use chrono::Local;

fn main() {
    let now = Local::now();
    println!("{}", now);
}

這個程式使用chrono crate的Local::now()函式讀取系統時間，並將其格式化為ISO 8601標準。

時間和時區的組態

要使用chrono crate，需要在Cargo.toml檔案中新增相應的依賴：

[package]
name = "clock"
version = "0.1.0"
edition = "2018"

[dependencies]
chrono = "0.4"

這個組態檔案指定了程式的名稱、版本和編譯器版本，以及對chrono crate的依賴。

內容解密：

  • 時間和時區的表示方法：不同的系統和語言對時間和時區有不同的表示方法，包括Unix時間、Windows FILETIME和Rust的chronos crate。
  • 時間格式化：ISO 8601是一個國際標準，定義了日期和時間的格式。Rust語言的chrono crate提供了一種簡單和方便的方式來讀取系統時間並格式化為ISO 8601標準。
  • 時間和時區的組態：要使用chrono crate，需要在Cargo.toml檔案中新增相應的依賴。

圖表翻譯：

  graph LR
    A[時間和時區] -->|表示方法|> B[Unix時間]
    A -->|表示方法|> C[Windows FILETIME]
    A -->|表示方法|> D[Rust的chronos crate]
    B -->|格式化|> E[ISO 8601標準]
    C -->|格式化|> E
    D -->|格式化|> E

這個圖表展示了時間和時區的表示方法和格式化過程。時間和時區可以使用不同的方法來表示，包括Unix時間、Windows FILETIME和Rust的chronos crate。這些方法都可以格式化為ISO 8601標準。

時間與時區：深入瞭解時間處理

時間是電腦科學中一個基本概念，然而它的複雜性往往被忽視。時間不僅僅是一個簡單的數值，它還涉及到時區、時差、閏秒等問題。在本章中，我們將深入探討時間處理的世界，並探索如何使用Rust語言來處理時間相關的問題。

時間格式化：ISO 8601和電子郵件標準

我們先來看一個簡單的應用程式，叫做clock，它可以報告當前的時間。這個應用程式將在整個章節中不斷被增強，以支援手動設定時間和透過NTP（網路時間協定）設定時間。現在，我們先來看一下編譯和執行clock應用程式的結果。

$ cd ch9/ch9-clock1
$ cargo run -- --use-standard rfc2822

這將輸出當前的時間，格式化為RFC 2822標準。

時間處理的複雜性

時間處理的複雜性在於它涉及到多個因素，包括時區、時差、閏秒等。為了簡化這個問題，我們可以使用chrono函式庫，它提供了一個簡單的介面來處理時間相關的問題。

從底層網路通訊到高階時間同步機制的全面檢視顯示，使用 Rust 語言實作 DNS 查詢需要關注多個層面的技術細節。分析段落中，我們逐步解析了 DNS 查詢的流程，涵蓋了 DNS 訊息的構建、UDP Socket 的建立與設定、請求的傳送和回應的接收，以及解析 IP 位址的關鍵步驟。同時，我們也深入探討了時間與時序的維護，特別是 NTP 客戶端的建立及其在分散式系統中的重要性，並強調了時間同步的挑戰和解決方案。

展望未來，隨著網路應用對精確時間同步的需求日益增長，更高效、更穩定的時間同步技術將成為重要的發展方向。預計未來 DNS 查詢的效能最佳化和安全性提升也將持續受到關注，例如 DNS over HTTPS (DoH) 和 DNS over TLS (DoT) 等技術的應用將更加普及。

玄貓認為，掌握 Rust 語言的網路程式設計技巧，並深入理解時間與時序的處理機制，對於構建高效能、高可靠性的網路應用至關重要。對於追求極致效能的開發者而言，深入研究 Rust 的非同步程式設計模型和時間處理函式庫，將有助於進一步提升應用程式的效能和穩定性。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。